#!/bin/sh

# A Poor(but Free)'s Man dtrace
#
# Copyright (C) 2014-2020 Free Software Foundation, Inc.
#
# Contributed by Oracle, Inc.
#
# This file is part of GDB.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see
# <http://www.gnu.org/licenses/>.

# DISCLAIMER DISCLAIMER DISCLAIMER
# This script is a test tool.  As such it is in no way intended to
# replace the "real" dtrace command for any practical purpose, apart
# from testing the DTrace USDT probes support in GDB.

# that said...
#
# pdtrace is a limited dtrace program, implementing a subset of its
# functionality:
#
# - The generation of an ELF file containing an embedded dtrace
#   program.  Equivalent to dtrace -G.
#
# - The generation of a header file with definitions for static
#   probes.  Equivalent to dtrace -h.
#
# This allows to generate DTrace static probes without having to use
# the user-level DTrace components.  The generated objects are 100%
# compatible with DTrace and can be traced by the dtrace kernel module
# like if they were generated by dtrace.
#
# Some of the known limitations of this implementation are:
# - The input d-script must describe one provider, and only one.
# - The "probe " directives in the d-file must not include argument
#   names, just the types.  Thus something like `char *' is valid, but
#   `char *name' is not.
# - The command line options must precede other arguments, since the
#   script uses the (more) portable getopts.
# - Each probe header in the d-script must be contained in
#   a single line.
# - strip -K removes the debugging information from the input object
#   file.
# - The supported target platforms are i[3456]86 and x86_64.
#
# Please keep this code as portable as possible.  Restrict yourself to
# POSIX sh.

# This script uses the following external programs, defined in
# variables.  Some of them are substituted by autoconf.

TR=tr
NM=@NM_TRANSFORM_NAME@
EGREP=egrep
SED=sed
CUT=cut
READELF=@READELF_TRANSFORM_NAME@
SORT=sort
EXPR=expr
WC=wc
UNIQ=uniq
HEAD=head
SEQ=seq
AS=@GAS_TRANSFORM_NAME@
STRIP=@STRIP_TRANSFORM_NAME@
TRUE=true

# Sizes for several DOF structures, in bytes.
#
# See linux/dtrace/dof.h for the definition of the referred
# structures.

dof_hdrsize=64      # sizeof(dtrace_dof_hdr)
dof_secsize=32      # sizeof(dtrace_dof_sect)
dof_probesize=48    # sizeof(dtrace_dof_probe)
dof_providersize=44 # sizeof(dtrace_dof_provider)

# Types for the several DOF sections.
#
# See linux/dtrace/dof_defines.h for a complete list of section types
# along with their values.

dof_sect_type_strtab=8
dof_sect_type_provider=15
dof_sect_type_probes=16
dof_sect_type_prargs=17
dof_sect_type_proffs=18
dof_sect_type_prenoffs=26

### Functions

# Write a message to the standard error output and exit with an error
# status.
#
# Arguments:
#   $1 error message.

f_panic()
{
    echo "error: $1" 1>&2; exit 1
}

# Write a usage message to the standard output and exit with an error
# status.

f_usage()
{
    printf "Usage: pdtrace [-32|-64] [-GhV] [-o output] [-s script] [ args ... ]\n\n"

    printf "\t-32 generate 32-bit ELF files\n"
    printf "\t-64 generate 64-bit ELF files\n\n"

    printf "\t-G  generate an ELF file containing embedded dtrace program\n"
    printf "\t-h  generate a header file with definitions for static probes\n"
    printf "\t-o  set output file\n"
    printf "\t-s  handle probes according to the specified D script\n"
    printf "\t-V  report the DTrace API version implemented by the tool\n"
    exit 2
}

# Write a version message to the standard output and exit with a
# successful status.

f_version()
{
    echo "pdtrace: Sun D 1.6.3"
    exit
}

# Add a new record to a list and return it.
#
# Arguments:
# $1 is the list.
# $2 is the new record

f_add_record()
{
    rec=$1
    test -n "$rec" && \
        { rec=$(printf %s\\n "$rec"; echo x); rec=${rec%x}; }
    printf %s "$rec$2"
}

# Collect the providers and probes information from the input object
# file.
#
# This function sets the values of the following global variables.
# The values are structured in records, each record in a line.  The
# fields of each record are separated in some cases by white
# characters and in other cases by colon (:) characters.
#
# The type codes in the line format descriptors are:
# S: string, D: decimal number
#
# probes
#   Regular probes and is-enabled probes.
#   TYPE(S) PROVIDER(S) NAME(S) OFFSET(D) BASE(D) BASE_SYM(S)
# base_probes
#   Base probes, i.e. probes sharing provider, name and container.
#   PROVIDER(S) NAME(S) BASE(D) BASE_SYM(S)
# providers
#   List of providers.
#   PROVIDER(S)
# All the offsets are expressed in bytes.
#
# Input globals:
#  objfile
# Output globals:
#  probes, base_probes, providers

probes=
base_probes=
providers=
probes_args=

f_collect_probes()
{
    # Probe points are function calls to undefined functions featuring
    # distinct names for both normal probes and is-enabled probes.
    PROBE_REGEX="(__dtrace_([a-zA-Z_]+)___([a-zA-Z_]+))"
    EPROBE_REGEX="(__dtraceenabled_([a-zA-Z_]+)___([a-zA-Z_]+))"

    while read type symbol provider name; do
          test -z "$type" && f_panic "No probe points found in $objfile"

          provider=$(printf %s $provider | $TR -s _)
          name=$(printf %s $name | $TR -s _)

          # Search the object file for relocations defined for the
          # probe symbols.  Then calculate the base address of the
          # probe (along with the symbol associated with that base
          # address) and the offset of the probe point.
          for offset in $($READELF -W -r $objfile | $EGREP $symbol | $CUT -d' ' -f1)
          do
              # Figure out the base address for the probe.  This is
              # done finding the function name in the text section of
              # the object file located above the probed point.  But
              # note that the relocation is for the address operand of
              # the call instruction, so we have to subtract 1 to find
              # the real probed point.
              offset=$((0x$offset - 1))

              # The addresses of is-enabled probes must point to the
              # first NOP instruction in their patched instructions
              # sequences, so modify them (see f_patch_objfile for the
              # instruction sequences).
              if test "$type" = "e"; then
                  if test "$objbits" -eq "32"; then
                      offset=$((offset + 2))
                  else # 64 bits
                      offset=$((offset + 3))
                  fi
              fi
              
              # Determine the base address of the probe and its
              # corresponding function name.
              funcs=$($NM -td $objfile | $EGREP "^[0-9]+ T " \
                      | $CUT -d' ' -f1,3 | $SORT -n -r | $TR ' ' :)
              for fun in $funcs; do
                  func_off=$(printf %s $fun | $CUT -d: -f1)
                  func_sym=$(printf %s $fun | $CUT -d: -f2)
                  # Note that `expr' is used to remove leading zeros
                  # to avoid FUNC_OFF to be interpreted as an octal
                  # number in arithmetic contexts.
                  test "$func_off" -le "$offset" && \
                      { base=$($EXPR $func_off + 0); break; }
              done
              test -n "$base" || \
                f_panic "could not find base address for probe at $objfile($o)"

              # Emit the record for the probe.
              probes=$(f_add_record "$probes" \
                                    "$type $provider $name $(($offset - $base)) $base $func_sym")
          done
      done <<EOF
$($NM $objfile | $EGREP " U $PROBE_REGEX" \
            | $SED -E -e "s/.*$PROBE_REGEX.*/p \1 \2 \3/";
     $NM $objfile | $EGREP " U $EPROBE_REGEX" \
         | $SED -E -e "s/.*$EPROBE_REGEX.*/e \1 \2 \3/")
EOF

    # Build the list of providers and of base probes from the probes.
    while read type provider name offset base base_sym; do
        providers=$(f_add_record "$providers" "$provider")
        base_probes=$(f_add_record "$base_probes" "$provider $name $base $base_sym")
    done <<EOF
$probes
EOF
    providers=$(printf %s\\n "$providers" | $SORT | $UNIQ)
    base_probes=$(printf %s\\n "$base_probes" | $SORT | $UNIQ)
}

# Collect the argument counts and type strings for all the probes
# described in the `probes' global variable.  This is done by
# inspecting the d-script file provided by the user.
#
# This function sets the values of the following global variables.
# The values are structured in records, each record in a line.  The
# fields of each record are separated in some cases by white
# characters and in other cases by colon (:) characters.
#
# The type codes in the line format descriptors are:
# S: string, D: decimal number
#
# probes_args
#   Probes arguments.
#   PROVIDER(S):NAME(S):NARGS(D):ARG1(S):ARG2(S):...:ARGn(S)
#
# Input globals:
#  probes
# Output globals:
#  probes_args
# Arguments:
#   $1 is the d-script file from which to extract the arguments
#      information.

f_collect_probes_args()
{
    dscript=$1
    while read type provider name offset base base_sym; do
        # Process normal probes only.  Is-enabled probes are not
        # described in the d-script file and they don't receive any
        # argument.
        test "$type" = "p" || continue
        
        # Names are mangled in d-script files to make it possible to
        # have underscore characters as part of the provider name and
        # probe name.
        m_provider=$(printf %s $provider | $SED -e 's/_/__/g')
        m_name=$(printf %s $name | $SED -e 's/_/__/g')
        
        # Ignore this probe if the d-script file does not describe its
        # provider.
        $EGREP -q "provider +$m_provider" $dscript || continue
        
        # Look for the line containing the description of the probe.
        # If we can't find it then ignore this probe.
        line=$($EGREP "^ *probe +$m_name *\(.*\);" $dscript)
        test -n "$line" || continue
        
        # Ok, extract the argument types from the probe prototype.
        # This is fragile as hell as it requires the prototype to be
        # in a single line.
        args=""; nargs=0; line=$(printf %s "$line" | $SED -e 's/.*(\(.*\)).*/\1/')
        set -f; IFS=,
        for arg in $line; do
            args="$args:$arg"
            nargs=$((nargs + 1))
        done
        set +f; unset IFS

        # Emit the record for the probe arguments.
        probes_args=$(f_add_record "$probes_args" "$provider:$name:$nargs$args")
    done <<EOF
$probes
EOF
}

# Functions to manipulate the global BCOUNT.

BCOUNT=0

f_incr_bcount()
{
    BCOUNT=$((BCOUNT + $1))
}

f_align_bcount()
{
    test $((BCOUNT % $1)) -eq 0 || BCOUNT=$((BCOUNT + ($1 - (BCOUNT % $1))))
}

# Generate a line of assembly code and add it to the asmprogram global
# variable.
#
# Arguments:
#   $1 string to generate in a line.

asmprogram=

f_gen_asm()
{
    line=$(printf "\t$1")
    asmprogram=$(f_add_record "$asmprogram" "$line")
}

# Helper function to generate the assembly code of a DOF section
# header.
#
# This function is used by `f_gen_dof_program'.
#
# Arguments:
#   $1 is the name of the described section.
#   $2 is the type of the described section.
#   $3 is the alignment of the described section.
#   $4 is the number of entities stored in the described section.
#   $5 is the offset in the DOF program of the described section.
#   $6 is the size of the described section, in bytes.

f_gen_dof_sect_header()
{
    f_gen_asm ""
    f_gen_asm "/* dtrace_dof_sect for the $1 section.  */"
    f_gen_asm ".balign 8"
    f_gen_asm ".4byte $2\t/* uint32_t dofs_type  */"
    f_gen_asm ".4byte $3\t/* uint32_t dofs_align  */"
    # The DOF_SECF_LOAD flag is 1 => loadable section.
    f_gen_asm ".4byte 1\t/* uint32_t dofs_flags  */"
    f_gen_asm ".4byte $4\t/* uint32_t dofs_entsize  */"
    f_gen_asm ".8byte $5\t/* uint64_t dofs_offset  */"
    f_gen_asm ".8byte $6\t/* uint64_t dofs_size  */"
}

# Generate a DOF program and assembly it in the output file.
#
# The DOF program generated by this function has the following
# structure:
#
# HEADER
# STRTAB OFFTAB EOFFTAB [PROBES PROVIDER]...
# STRTAB_SECT OFFTAB_SECT EOFFTAB_SECT ARGTAB_SECT [PROBES_SECT PROVIDER_SECT]...
#
# Input globals:
#   probes, base_probes, providers, probes_args, BCOUNT

f_gen_dof_program()
{   
    ###### Variables used to cache information needed later.
    
    # Number of section headers in the generated DOF program.
    dof_secnum=0
    # Offset of section headers in the generated DOF program, in bytes.
    dof_secoff=0

    # Sizes of the STRTAB, OFFTAB and EOFFTAB sections, in bytes.
    strtab_size=0
    offtab_size=0
    eofftab_size=0
    
    # Offsets of the STRTAB, OFFTAB EOFFTAB and PROBES sections in the
    # generated DOF program.  In bytes.
    strtab_offset=0
    offtab_offset=0
    eofftab_offset=0
    argtab_offset=0
    probes_offset=0
    
    # Indexes of the section headers of the STRTAB, OFFTAB, EOFFTAB and
    # PROBES sections in the sections array.
    strtab_sect_index=0
    offtab_sect_index=0
    eofftab_sect_index=0
    argtab_sect_index=0
    probes_sect_index=0

    # First offsets and eoffsets of the base-probes.
    # Lines: PROVIDER(S) NAME(S) BASE(D) (DOF_OFFSET(D)|DOF_EOFFSET(D))
    probes_dof_offsets=
    probes_dof_eoffsets=
    
    # Offsets in the STRTAB section for the first type of base probes.
    # Record per line: PROVIDER(S) NAME(S) BASE(D) OFFSET(D)
    probes_dof_types=


    # Offsets of the provider names in the provider's STRTAB section.
    # Lines: PROVIDER(S) OFFSET(D)
    providers_dof_names=

    # Offsets of the base-probe names in the provider's STRTAB section.
    # Lines: PROVIDER(S) NAME(S) BASE(D) OFFSET(D)
    probes_dof_names=
    
    # Offsets of the provider sections in the DOF program.
    # Lines: PROVIDER(S) OFFSET(D)
    providers_offsets=

    ###### Generation phase.
    
    # The header of the DOF program contains a `struct
    # dtrace_dof_hdr'.  Record its size, but it is written at the end
    # of the function.
    f_incr_bcount $dof_hdrsize; f_align_bcount 8

    # The STRTAB section immediately follows the header.  It contains
    # the following set of packed null-terminated strings:
    #
    # [PROVIDER [BASE_PROBE_NAME [BASE_PROBE_ARG_TYPE...]]...]...
    strtab_offset=$BCOUNT
    strtab_sect_index=$dof_secnum
    dof_secnum=$((dof_secnum + 1))
    f_gen_asm ""
    f_gen_asm "/* The STRTAB section.  */"
    f_gen_asm ".balign 8"
    # Add the provider names.
    off=0
    while read provider; do
        strtab_size=$(($strtab_size + ${#prov} + 1))
        # Note the funny mangling...
        f_gen_asm ".asciz \"$(printf %s $provider | $TR _ -)\""
        providers_dof_names=$(f_add_record "$providers_dof_names" \
                                           "$provider $off")
        off=$(($off + ${#provider} + 1))

        # Add the base-probe names.
        while read p_provider name base base_sym; do
            test "$p_provider" = "$provider" || continue
            # And yes, more funny mangling...
            f_gen_asm ".asciz \"$(printf %s $name | $TR _ -)\""
            probes_dof_names=$(f_add_record "$probes_dof_names" \
                                            "$p_provider $name $base $off")
            off=$(($off + ${#name} + 1))
            while read args; do
                a_provider=$(printf %s "$args" | $CUT -d: -f1)
                a_name=$(printf %s "$args" | $CUT -d: -f2)
                test "$a_provider" = "$p_provider" \
                    && test "$a_name" = "$name" \
                    || continue

                probes_dof_types=$(f_add_record "$probes_dof_types" \
                                                "$a_provider $name $base $off")
                nargs=$(printf %s "$args" | $CUT -d: -f3)
                for n in $($SEQ $nargs); do
                    arg=$(printf %s "$args" | $CUT -d: -f$(($n + 3)))
                    f_gen_asm ".asciz \"${arg}\""
                    off=$(($off + ${#arg} + 1))
                done                
            done <<EOF
$probes_args
EOF
        done <<EOF
$base_probes
EOF
    done <<EOF
$providers
EOF
    strtab_size=$off
    f_incr_bcount $strtab_size; f_align_bcount 8

    # The OFFTAB section contains a set of 32bit words, one per
    # defined regular probe.
    offtab_offset=$BCOUNT
    offtab_sect_index=$dof_secnum
    dof_secnum=$((dof_secnum + 1))
    f_gen_asm ""
    f_gen_asm "/* The OFFTAB section.  */"
    f_gen_asm ".balign 8"
    off=0
    while read type provider name offset base base_sym; do
        test "$type" = "p" || continue
        f_gen_asm ".4byte $offset\t/* probe ${provider}:${name}  */"
        probes_dof_offsets=$(f_add_record "$probes_dof_offsets" \
                                          "$provider $name $base $off")
        off=$(($off + 4))
    done <<EOF
$probes
EOF
    offtab_size=$off
    f_incr_bcount $offtab_size; f_align_bcount 8

    # The EOFFTAB section contains a set of 32bit words, one per
    # defined is-enabled probe.
    eofftab_offset=$BCOUNT
    eofftab_sect_index=$dof_secnum
    dof_secnum=$((dof_secnum + 1))
    f_gen_asm ""
    f_gen_asm "/* The EOFFTAB section.  */"
    f_gen_asm ".balign 8"
    off=0
    while read type provider name offset base base_sym; do
        test "$type" = "e" || continue
        f_gen_asm ".4byte $offset\t/* is-enabled probe ${provider}:${name}  */"
        probes_dof_eoffsets=$(f_add_record "$probes_dof_eoffsets" \
                                           "$provider $name $base $off")
        off=$(($off + 4))
    done <<EOF
$probes
EOF
    eofftab_size=$off
    f_incr_bcount $eofftab_size; f_align_bcount 8

    # The ARGTAB section is empty, but nonetheless has a section
    # header, so record its section index here.
    argtab_offset=0
    argtab_sect_index=$dof_secnum
    dof_secnum=$((dof_secnum + 1))

    # Generate a pair of sections PROBES and PROVIDER for each
    # provider.
    while read prov; do
        # The PROBES section contains an array of `struct
        # dtrace_dof_probe'.
        #
        # A `dtrace_dof_probe' entry characterizes the collection of
        # probes and is-enabled probes sharing the same provider, name and
        # base address.
        probes_sect_index=$dof_secnum
        dof_secnum=$((dof_secnum + 1))
        probes_offset=$BCOUNT        
        num_base_probes=$(printf %s\\n "$base_probes" | $WC -l)
        while read provider name base base_sym; do
            name_offset=$(printf %s\\n "$probes_dof_names" \
                          | $EGREP "^$provider $name " | $CUT -d' ' -f4)

            num_offsets=$(printf %s\\n "$probes_dof_offsets" \
                          | $EGREP "^$provider $name [0-9]+ " | $WC -l)
            
            first_offset=0
            test "$num_offsets" -gt 0 && \
              first_offset=$(printf %s\\n "$probes_dof_offsets" \
                             | $EGREP "^$provider $name " | $CUT -d' ' -f4 | $HEAD -1)

            num_eoffsets=$(printf %s\\n "$probes_dof_eoffsets" \
                           | $EGREP "^$provider $name [0-9]+ " | $WC -l)
            first_eoffset=0
            test "$num_eoffsets" -gt 0 && \
              first_eoffset=$(printf %s "$probes_dof_eoffsets" \
                              | $EGREP "^$provider $name " | $CUT -d' ' -f4 | $HEAD -1)

            num_args=$(printf %s "$probes_args" \
                       | $EGREP "^$provider:$name:" | $CUT -d: -f3 | $HEAD -1)
 
            first_type=$(printf %s "$probes_dof_types" \
                         | $EGREP "^$provider $name $base " | $CUT -d' ' -f4 | $HEAD -1)

            reloctype=R_X86_64_GLOB_DAT
            test "$objbits" = "32" && reloctype=R_386_32
            
            f_gen_asm ""
            f_gen_asm "/* dtrace_dof_probe for ${provider}:${name} at ${base_sym}  */"
            f_gen_asm ".balign 8"
            f_gen_asm ".reloc ., $reloctype, $base_sym + 0"
            f_gen_asm ".8byte ${base}\t/* uint64_t dofpr_addr  */"
            f_gen_asm ".4byte 0\t/* uint32_t dofpr_func  */"
            f_gen_asm ".4byte $name_offset\t/* uint32_t dofpr_name   */"
            f_gen_asm ".4byte $first_type\t/* uint32_t dofpr_nargv  */"
            f_gen_asm ".4byte 0\t/* uint32_t dofpr_xargv  */"
            f_gen_asm ".4byte 0\t/* uint32_t dofpr_argidx */"
            f_gen_asm ".4byte $(($first_offset/4))\t/* uint32_t dofpr_offidx  */"
            f_gen_asm ".byte  $num_args\t/* uint8_t dofpr_nargc  */"
            f_gen_asm ".byte  0\t/* uint8_t dofpr_xargc  */"
            f_gen_asm ".2byte $num_offsets\t/* uint16_t dofpr_noffs  */"
            f_gen_asm ".4byte $(($first_eoffset/4))\t/* uint32_t dofpr_enoffidx  */"
            f_gen_asm ".2byte $num_eoffsets\t/* uint16_t dofpr_nenoffs  */"
            f_gen_asm ".2byte 0\t/* uint16_t dofpr_pad1  */"
            f_gen_asm ".4byte 0\t/* uint16_t dofpr_pad2  */"

            f_incr_bcount "$dof_probesize"
        done <<EOF
$base_probes
EOF

        # The PROVIDER section contains a `struct dtrace_dof_provider'
        # instance describing the provider for the probes above.
        dof_secnum=$((dof_secnum + 1))
        providers_offsets=$(f_add_record "$providers_offsets" \
                                         "$prov $BCOUNT")
        # The dtrace_dof_provider.
        provider_name_offset=$(printf %s "$providers_dof_names" \
                                      | $EGREP "^$prov " | $CUT -d' ' -f2)

        f_gen_asm ""
        f_gen_asm "/* dtrace_dof_provider for $prov  */"
        f_gen_asm ".balign 8"
        # Links to several DOF sections.
        f_gen_asm ".4byte $strtab_sect_index\t/* uint32_t dofpv_strtab  */"
        f_gen_asm ".4byte $probes_sect_index\t/* uint32_t dofpv_probes  */"
        f_gen_asm ".4byte $argtab_sect_index\t/* uint32_t dofpv_prargs  */"
        f_gen_asm ".4byte $offtab_sect_index\t/* uint32_t dofpv_proffs  */"
        # Offset of the provider name into the STRTAB section.
        f_gen_asm ".4byte $provider_name_offset\t/* uint32_t dofpv_name  */"
        # The rest of fields can be 0 for our modest purposes :)
        f_gen_asm ".4byte 0\t/* uint32_t dofpv_provattr  */"
        f_gen_asm ".4byte 0\t/* uint32_t dofpv_modattr  */"
        f_gen_asm ".4byte 0\t/* uint32_t dofpv_funcattr  */"
        f_gen_asm ".4byte 0\t/* uint32_t dofpv_nameattr  */"
        f_gen_asm ".4byte 0\t/* uint32_t dofpv_argsattr  */"
        # But not this one, of course...
        f_gen_asm ".4byte $eofftab_sect_index\t/* uint32_t dofpv_prenoffs  */"

        f_incr_bcount $dof_providersize
    done<<EOF
$providers
EOF
    f_align_bcount 8

    # The section headers follow, one per section defined above.
    dof_secoff=$BCOUNT

    f_gen_dof_sect_header STRTAB \
                          $dof_sect_type_strtab \
                          1 1 $strtab_offset $strtab_size
    f_incr_bcount $dof_secsize; f_align_bcount 8

    f_gen_dof_sect_header OFFTAB \
                          $dof_sect_type_proffs \
                          4 4 $offtab_offset $offtab_size
    f_incr_bcount $dof_secsize; f_align_bcount 8

    f_gen_dof_sect_header EOFFTAB \
                          $dof_sect_type_prenoffs \
                          4 4 $eofftab_offset $eofftab_size
    f_incr_bcount $dof_secsize; f_align_bcount 8

    f_gen_dof_sect_header ARGTAB \
                          $dof_sect_type_prargs \
                          4 1 $argtab_offset 0
    f_incr_bcount $dof_secsize; f_align_bcount 8
    
    while read provider; do
        provider_offset=$(printf %s "$providers_offsets" \
                          | $EGREP "^$provider " | $CUT -d' ' -f2)
        num_base_probes=$(printf %s\\n "$base_probes" | $WC -l)

        f_gen_dof_sect_header "$provider probes" \
                              $dof_sect_type_probes \
                              8 $dof_probesize $probes_offset \
                              $((num_base_probes * dof_probesize))
        f_incr_bcount $dof_secsize; f_align_bcount 8

        f_gen_dof_sect_header "$provider provider" \
                              $dof_sect_type_provider \
                              8 1 $provider_offset $dof_providersize
        f_incr_bcount $dof_secsize; f_align_bcount 8
    done <<EOF
$providers
EOF

    # Finally, cook the header.
    asmbody="$asmprogram"
    asmprogram=""
    f_gen_asm "/* File generated by pdtrace.  */"
    f_gen_asm ""

    f_gen_asm ".section .SUNW_dof,\"a\",\"progbits\""
    f_gen_asm ".globl __SUNW_dof"
    f_gen_asm ".hidden __SUNW_dof"
    f_gen_asm ".size __SUNW_dof, ${BCOUNT}"
    f_gen_asm ".type __SUNW_dof, @object"
    f_gen_asm "__SUNW_dof:"

    f_gen_asm ""
    f_gen_asm "/* dtrace_dof_hdr */"
    f_gen_asm ".balign 8"
    f_gen_asm ".byte  0x7f, 'D, 'O, 'F\t/* dofh_ident[0..3] */"
    f_gen_asm ".byte  2\t\t/* model: 1=ILP32, 2=LP64 */"
    f_gen_asm ".byte  1\t\t/* encoding: 1: little-endian, 2: big-endian */"
    f_gen_asm ".byte  2\t\t/* DOF version: 1 or 2.  Latest is 2 */"
    f_gen_asm ".byte  2\t\t/* DIF version: 1 or 2.  Latest is 2 */"
    f_gen_asm ".byte  8\t\t/* number of DIF integer registers */"
    f_gen_asm ".byte  8\t\t/* number of DIF tuple registers */"
    f_gen_asm ".byte  0, 0\t\t/* dofh_ident[10..11] */"
    f_gen_asm ".4byte 0\t\t/* dofh_ident[12..15] */"
    f_gen_asm ".4byte 0\t/* uint32_t dofh_flags  */"  # See Limitations above.
    f_gen_asm ".4byte ${dof_hdrsize}\t/* uint32_t dofh_hdrsize  */"
    f_gen_asm ".4byte ${dof_secsize}\t/* uint32_t dofh_secsize */"
    f_gen_asm ".4byte ${dof_secnum}\t/* uint32_t dofh_secnum  */"
    f_gen_asm ".8byte ${dof_secoff}\t/* uint64_t dofh_secoff  */"
    f_gen_asm ".8byte ${BCOUNT}\t/* uint64_t dofh_loadsz  */"
    f_gen_asm ".8byte ${BCOUNT}\t/* uint64_t dofh_filesz  */"
    f_gen_asm ".8byte 0\t/* uint64_t dofh_pad  */"
    f_gen_asm ""

    # Ok, now assembly the program in OFILE
    echo "$asmprogram$asmbody" | $AS -$objbits -o $ofile

    # Next step is to change the sh_type of the ".SUNW_dof" section
    # headers to 0x6ffffff4 (SHT_SUNW_dof).
    #
    # Note that this code relies in the fact that readelf will list
    # the sections ordered in the same order than the section headers
    # in the section header table of the file.
    elfinfo=$($READELF -a $ofile)

    # Mind the endianness.
    if printf %s "$elfinfo" | $EGREP -q "little endian"; then
        sht_sunw_dof=$(printf %s%s%s%s \\364 \\377 \\377 \\157)
    else
        sht_sunw_dof=$(printf %s%s%s%s \\157 \\377 \\377 \\364)
    fi

    shdr_start=$(printf %s "$elfinfo" \
                | $EGREP "^[ \t]*Start of section headers:" \
                | $SED -E -e 's/.*headers:[ \t]*([0-9]+).*/\1/')
    test -n "$shdr_start" \
        || f_panic "could not extract the start of shdr from $ofile"

    shdr_num_entries=$(printf %s "$elfinfo" \
                       | $EGREP "^[ \t]*Size of section headers:" \
                       | $SED -E -e 's/.*headers:[ \t]*([0-9]+).*/\1/')
    test -n "$shdr_num_entries" \
         || f_panic "could not extract the number of shdr entries from $ofile"

    shdr_entry_size=$(printf %s "$elfinfo" \
                      | $EGREP "^[ \t]*Size of section headers:" \
                      | $SED -E -e 's/.*headers:[ \t]*([0-9]+).*/\1/')
    test -n "$shdr_entry_size" \
         || f_panic "could not fetch the size of section headers from $ofile"

    while read line; do
        data=$(printf %s "$line" \
               | $SED -E -e 's/.*\[(.*)\][ \t]+([a-zA-Z_.]+).*/\1:\2/')
        num=$(printf %s "$data" | $CUT -d: -f1)
        name=$(printf %s "$data" | $CUT -d: -f2)
        if test "$name" = ".SUNW_dof"; then
            # Patch the new sh_type in the proper entry of the section
            # header table.
            printf "$sht_sunw_dof" \
                   | dd of=$ofile conv=notrunc count=4 ibs=1 bs=1 \
                        seek=$((shdr_start + (shdr_entry_size * num) + 4)) \
                        2> /dev/null
            break
        fi
    done <<EOF
$(printf %s "$elfinfo" | $EGREP "^[ \t]*\[[0-9 ]+\].*[A-Z]+.*PROGBITS")
EOF

}

# Patch the probed points in the given object file, replacing the
# function calls with NOPs.
#
# The probed points in the input object files are function calls.
# This function replaces these function calls by some other
# instruction sequences.  Which replacement to use depends on several
# factors, as documented below.
#
# Arguments:
#  $1 is the object file to patch.

f_patch_objfile()
{
    objfile=$1
    
    # Several x86_64 instruction opcodes, in octal.
    x86_op_nop=$(printf \\220)
    x86_op_ret=$(printf \\303)
    x86_op_call=$(printf \\350)
    x86_op_jmp32=$(printf \\351)
    x86_op_rex_rax=$(printf \\110)
    x86_op_xor_eax_0=$(printf \\063)
    x86_op_xor_eax_1=$(printf \\300)
    
    # Figure out the file offset of the text section in the object
    # file.
    text_off=0x$(objdump -j .text -h $objfile \
                 | grep \.text | $TR -s ' ' | $CUT -d' ' -f 7)

    while read type provider name offset base base_sym; do
        # Calculate the offset of the probed point in the object file.
        # Note that the `offset' of is-enabled probes is tweaked in
        # `f_collect_probes" to point ahead the patching point.
        probe_off=$((text_off + base + offset))
        if test "$type" = "e"; then
            if test "$objbits" -eq "32"; then
                probe_off=$((probe_off - 2))
            else # 64 bits
                probe_off=$((probe_off - 3))
            fi
        fi

        # The probed point can be either a CALL instruction or a JMP
        # instruction (a tail call).  This has an impact on the
        # patching sequence.  Fetch the first byte at the probed point
        # and do the right thing.
        nopret="$x86_op_nop"
        byte=$(dd if=$objfile count=1 ibs=1 bs=1 skip=$probe_off 2> /dev/null)
        test "$byte" = "$x86_op_jmp32" && nopret="$x86_op_ret"

        # Determine the patching sequence.  It depends on the type of
        # probe at hand (regular or is-enabled) and also if
        # manipulating a 32bit or 64bit binary.
        patchseq=
        case $type in
            p) patchseq=$(printf %s%s%s%s%s \
                                 "$nopret" \
                                 "$x86_op_nop" \
                                 "$x86_op_nop" \
                                 "$x86_op_nop" \
                                 "$x86_op_nop")
               ;;
            e) test "$objbits" -eq 64 && \
                 patchseq=$(printf %s%s%s%s%s \
                                   "$x86_op_rex_rax" \
                                   "$x86_op_xor_eax_0" \
                                   "$x86_op_xor_eax_1" \
                                   "$nopret" \
                                   "$x86_op_nop")
               test "$objbits" -eq 32 && \
                 patchseq=$(printf %s%s%s%s%s \
                                   "$x86_op_xor_eax_0" \
                                   "$x86_op_xor_eax_1" \
                                   "$nopret" \
                                   "$x86_op_nop" \
                                   "$x86_op_nop")
               ;;
            *) f_panic "internal error: wrong probe type $type";;
        esac

        # Patch!
        printf %s "$patchseq" \
               | dd of=$objfile conv=notrunc count=5 ibs=1 bs=1 seek=$probe_off 2> /dev/null
    done <<EOF
$probes
EOF
    
    # Finally, we have to remove the __dtrace_* and __dtraceenabled_*
    # symbols from the object file, along with their respective
    # relocations.
    #
    # Note that the most obvious call:
    #   strip -v -N whatever -w foo.o
    # will not work:
    #   strip: not stripping symbol `whatever' because it is named in a relocation
    #
    # Fortunately using `-K !whatever' instead tricks strip to do the
    # right thing, but this is black magic and may eventually stop
    # working...
    $STRIP -K '!__dtrace_*' -w $objfile
    $STRIP -K '!__dtraceenabled_*' -w $objfile
}

# Read the input .d file and print a header file with macros to
# invoke the probes defined in it.

f_gen_header_file()
{
    guard=$(basename $ofile | $TR - _ | $CUT -d. -f1 | $TR a-z A-Z)
    printf "/*\n * Generated by pdtrace.\n */\n\n"

    printf "#ifndef _${guard}_H\n"
    printf "#define _${guard}_H\n\n"

    printf "#include <unistd.h>\n"
    printf "#include <inttypes.h>\n"
    printf \\n\\n

    printf "#ifdef __cplusplus\nextern \"C\" {\n#endif\n"

    printf "#define _DTRACE_VERSION 1\n\n"

    provider=$(cat $dfile | $EGREP "^ *provider +([a-zA-Z_]+)" \
               | $SED -E -e 's/^ *provider +([a-zA-Z]+).*/\1/')
    test -z "$provider" \
        && f_panic "unable to parse the provider name from $dfile."
    u_provider=$(printf %s "$provider" | $TR a-z A-Z | $TR -s _)
    
    cat $dfile | $EGREP "^ *probe +[a-zA-Z_]+ *\(.*\);" | \
        while read line; do
            # Extract the probe name.
            name=$(printf %s "$line" \
                   | $SED -E -e 's/^ *probe +([a-zA-Z_]+).*/\1/')
            u_name=$(printf %s "$name" | $TR a-z A-Z | $TR -s _)

            # Generate an arg1,arg2,...,argN line for the probe.
            args=""; nargs=0; aline=$(printf %s "$line" | $SED -e 's/.*(\(.*\)).*/\1/')
            set -f; IFS=,
            for arg in $aline; do
                args="${args}arg${nargs},"
                nargs=$((nargs + 1))
            done
            set +f; unset IFS
            args=${args%,}

            echo "#if _DTRACE_VERSION"
            echo ""
            
            # Emit the macros for the probe.
            echo "#define ${u_provider}_${u_name}($args) \\"
            echo "   __dtrace_${provider}___${name}($args)"
            echo "#define ${u_provider}_${u_name}_ENABLED() \\"
            echo "   __dtraceenabled_${provider}___${name}()"

            # Emit the extern definitions for the probe dummy
            # functions.
            echo ""
            printf %s\\n "$line" \
                | $SED -E -e "s/^ *probe +/extern void __dtrace_${provider}___/"
            echo "extern int __dtraceenabled_${provider}___${name}(void);"


            printf "\n#else\n"

            # Emit empty macros for the probe
            echo "#define ${u_provider}_${u_name}($args)"
            echo "#define ${u_provider}_${u_name}_ENABLED() (0)"

            printf "\n#endif /* _DTRACE_VERSION */\n"
        done

    printf "#ifdef __cplusplus\n}\n#endif\n\n"
    printf "#endif /* _${guard}_H */\n"
}

### Main program.

# Process command line arguments.

test "$#" -eq "0" && f_usage

genelf=0
genheader=0
objbits=64
ofile=
dfile=
while getopts VG3264hs:o: name; do
    case $name in
        V) f_version;;
        s) dfile="$OPTARG";
           test -f "$dfile" || f_panic "cannot read $dfile";;
        o) ofile="$OPTARG";;
        G) genelf=1;;
        h) genheader=1;;
        # Note the trick to support -32
        3) objbits=666;;
        2) test "$objbits" -eq 666 || f_usage; objbits=32;;
        # Likewise for -64
        6) objbits=777;;
        4) test "$objbits" -eq 777 || f_usage; objbits=64;;
        ?) f_usage;;
    esac
done
shift $(($OPTIND - 1))

test "$objbits" -eq "32" || test "$objbits" -eq "64" \
    || f_usage

test $((genelf + genheader)) -gt 1 && \
    { echo "Please use either -G or -h."; f_usage; }

test -n "$dfile" || { echo "Please specify a .d file with -s."; exit 2; }

if test "$genelf" -gt 0; then
    # In this mode there must be a remaining argument: the name of the
    # object file to inspect for probed points.
    test "$#" -ne "1" && f_usage
    test -f "$1" || f_panic "cannot read $1"
    objfile=$1

    # Collect probe information from the input object file and the
    # d-script.
    f_collect_probes $objfile    
    f_collect_probes_args $dfile

    # Generate the assembly code and assemble the DOF program in
    # OFILE.  Then patch OBJFILE to remove the dummy probe calls.
    f_gen_dof_program
    f_patch_objfile $objfile
fi

if test "$genheader" -gt 0; then
    test -n "$ofile" || { echo "Please specify an output file with -o."; exit 2; }
    
    # In this mode no extra arguments shall be present.
    test "$#" -ne "0" && f_usage

    f_gen_header_file > $ofile
fi

# pdtrace ends here.