C++函数签名解析

2013-11-29实际上不同这么烦锁，直接用objdump -C 或者c++file sourcefile就行了

orgmangle

首选

#! /bin/sh                                                                                                         

elfname=$1
objname=$2
targetname=""

thispid=$$

filename=/tmp/jerry.${thispid}

rm -f $filename

case $elfname in
    *.[sS]) 
        targetname=$elfname;
        ;;      
    *)
        objdump -D -z $elfname > ${elfname}.s;
        targetname=${elfname}.s;
        ;;      
    esac    

sed -n -e '/'${objname}'/p' $targetname | awk '{print $NF}' | sed -n -e 's/<\(.*\)>\(.*\)/\1/p' | sort -d | uniq >> $filename

for line in `sed -n -e 'p' $filename`
do
    dename=`c++filt $line`
    sed -i -e 's/'"${line}"'/'"${line}"'\t'"${dename}"'/' ${targetname} 
done

rm -f $filename

vtable重构，使用下个脚本

#! /bin/bash                                                                                                       

filename=$1
startline=$2
endline=$3

#vtable_parse自己写了二进制程序，参见下边
temp=`./vtable_parse $filename $startline $endline`

mv $temp $filename

//Makefile
PPFLAGS = -I./include                                                                                             

vtable_parse: vtable.cpp vfile.cpp basic_info.cpp
    g++ $(CPPFLAGS) -g $^ -o $@

// ./include/basic_info.h
#ifndef __JERRY_BASIC_INFO
#define __JERRY_BASIC_INFO


#include <iostream>
#include <fstream>                                                                                                 
#include <unistd.h>
#include <sys/types.h>
#include <string.h>
#include <stdlib.h>

using namespace std;

class BASIC_INFO
{
    private:
        char *strpid;
        char *infilename;
        char *outfilename;
        unsigned int start_line;
        unsigned int end_line;

        BASIC_INFO(const BASIC_INFO&);
        BASIC_INFO& operator= (const BASIC_INFO&);

        void pid_str(char **thiz, int value, int base);

    public: 
        BASIC_INFO(void);

        BASIC_INFO(const char *myinfile, const char* mystartline, const char *myendline);

        ~BASIC_INFO(void);

        void str_new(char **thiz, int length);

        void int_to_str(char *thiz, int value, int base);

        unsigned int str_to_int(const char *thiz, int base);
                                                                                                                   
        char *getinfilename(void)const;

        unsigned int getstart_line(void)const;

        unsigned int getend_line(void)const;

        char *getoutfilename(void)const;
};

#endif

// ./include/vfile.h

#ifndef __JERRY_VFILE                                                                                              
#define __JERRY_VFILE

#include <basic_info.h>

class VFILE:public BASIC_INFO
{
#define infile_open_mode  (std::ios_base::in)
#define outfile_open_mode (std::ios_base::out)
    private:
        ifstream infile; 
        ofstream outfile;

        char *alloc_pool;
        char *alloc_use_end;
        unsigned int pool_last;
        unsigned int start_label;
        unsigned int start_line;
        unsigned int end_line;

        void infile_read(void);

        void outfile_write(void);

        void file_fix_changed(int line_num);

        int get_label(void);

        void skip_blank(char **ptr); 

        unsigned int length_to_blank(const char *src);

        void copy_to_blank(char **src); 

        void skip_to_punc(char **ptr, char value); 

        int is_line_end(char *ptr);

        VFILE(void);
        VFILE(const VFILE&);
    public:
        
        VFILE(const char *myinfilename, const char *mystartline, 
              const char *myendline);
             

        void parse_file(void);

        void format_alloc(void);

        void parse_write(void);

        void last_write(void);

        ~VFILE(void);
};

#endif  

// vtable.cpp
#include <basic_info.h>                                                                                            
#include <vfile.h>
int main(int argc, char *argv[])
{

    VFILE vtable(argv[1], argv[2], argv[3]);

    vtable.parse_file();
    vtable.format_alloc();
    vtable.parse_write();
    vtable.last_write();

    cout << vtable.getoutfilename() << endl;

    return 0;
}

// basic_info.cpp
#include <basic_info.h>                                                                                            

BASIC_INFO::BASIC_INFO(void):
    strpid(NULL), infilename(NULL), outfilename(NULL),
    start_line(0), end_line(0){}

BASIC_INFO::BASIC_INFO(const char *myinfile, const char* mystartline, const char* myendline):
    strpid(NULL), infilename(NULL), outfilename(NULL),
    start_line(0), end_line(0)
{
    str_new(&strpid, 32);
    pid_str(&strpid, getpid(), 10);

    str_new(&infilename, strlen(myinfile) + 1);
    strcpy(infilename, myinfile);

    str_new(&outfilename, strlen("/tmp/") + strlen(infilename) + strlen(strpid) + 1);
    strcpy(outfilename, "/tmp/");
    strcat(outfilename, infilename);
    strcat(outfilename, strpid);

    start_line = str_to_int(mystartline, 10);
    end_line = str_to_int(myendline, 10);
}

BASIC_INFO::~BASIC_INFO(void)
{
    delete []strpid;
    delete []infilename;
    delete []outfilename;

    strpid = NULL;
    infilename = NULL;
    outfilename = NULL;
    start_line = 0;
    end_line = 0;
}

void BASIC_INFO::pid_str(char **thiz, int value, int base)
{
    int pid_seq = getpid();

    int_to_str(*thiz, value, base);
}

void BASIC_INFO::str_new(char **thiz, int length)
{
    if(*thiz != NULL)
        delete[](*thiz);

    *thiz = new char[length];

    if(*thiz == NULL)
    {
        cout << "allocate failed" << endl;
        exit(1);
    }
}


void BASIC_INFO::int_to_str(char *thiz, int value, int base)
{
    char *temp  = NULL;
    str_new(&temp, 32);

    char *start = temp;

    while(value)
    {
        *temp++ ="0123456789abcdef"[value % base]; 
        value = value / base;
    }

    *temp = 0;

    while(--temp >= start)
    {
        *thiz++ = *temp; 
    }

    *thiz = 0;

    delete[]start;
}

unsigned int BASIC_INFO::str_to_int(const char *thiz, int base)
{
    unsigned int temp = 0;
    while(*thiz)
    {
        if(!isalnum(*thiz))
            break;

        if(0 <= *thiz && *thiz <= '9')
            temp = (*thiz - '0') + temp * base;

        if('a'<= *thiz && *thiz <= 'f')
            temp = (*thiz - 'a' + 10) + temp * base;

        if('A'<= *thiz && *thiz <= 'F')
            temp = (*thiz - 'A' + 10) + temp * base;

        thiz++;
    }

    return temp;
}

char * BASIC_INFO::getinfilename(void)const
{
    return infilename;
}

unsigned int BASIC_INFO::getstart_line(void)const
{
    return start_line;
}

unsigned int BASIC_INFO::getend_line(void)const
{
    return end_line;
}

char * BASIC_INFO::getoutfilename(void)const
{
    return outfilename;
}            

// vtable.cpp

#include "vfile.h"                                                                                                 

VFILE::VFILE(void){} 

VFILE::VFILE(const VFILE&){}

VFILE::VFILE(const char *myinfilename, const char *mystartline, const char *myendline): 
             BASIC_INFO(myinfilename, mystartline, myendline),
             alloc_pool(NULL), start_label(0)
{
    infile.open(getinfilename(), infile_open_mode);
    outfile.open(getoutfilename(), outfile_open_mode);
    if(NULL == infile || NULL == outfile)
    {
        cout << "open file failed" << endl;
        exit(1);
    }
    infile.unsetf(ios::skipws);

    start_line = getstart_line();
    end_line = getend_line();

    start_label = get_label();
}

VFILE::~VFILE(void)
{
    if(infile)
        infile.close();
    if(outfile)
        outfile.close();
    if(alloc_pool)
        delete[]alloc_pool;

    alloc_pool = NULL; 
}

void VFILE::infile_read(void)
{
    infile.getline(alloc_pool, 300);
}

void VFILE::outfile_write(void)
{
    outfile << alloc_pool ;
}

void VFILE::file_fix_changed(int line_num)
{
    if(line_num)
    {
        int i = 0;
        for(i = 0; i < line_num; i++)
        {
            if(!infile.eof())
            {
                infile_read();
                outfile_write();
                outfile << '\n';
            }
        }
    }

    else
    {
        while(!infile.eof())
        {
            infile_read();
            outfile_write();
            outfile << '\n';
        }   
    }

}

int VFILE::get_label(void)
{
    str_new(&alloc_pool, 300);
    file_fix_changed(start_line);
    int temp = str_to_int(alloc_pool, 16);
    delete[]alloc_pool;
    alloc_pool = NULL;
    return temp;
}

void VFILE::skip_blank(char **ptr)
{
    char *temp = *ptr;

    while(isblank(*temp++))
        *ptr = *ptr + 1;
}

unsigned int VFILE::length_to_blank(const char *src)
{
    unsigned int length = 0;

    while((!isblank(*src)) && (*src != 0))
    {
        length++;
        src++;
    }

//  while(!isblank(*src++))
//      length++;

    return length;

}

void VFILE::copy_to_blank(char **src)
{
    unsigned int length = length_to_blank(*src);

    if(length > pool_last)
    {
        char *temp = new char[strlen(alloc_pool) + 1 + 50]; 
        strcpy(temp, alloc_pool);
        delete[]alloc_pool;
        alloc_pool = temp;
        alloc_use_end = alloc_pool + strlen(alloc_pool) + 1;
        pool_last = pool_last + 50;
    }

    pool_last = pool_last - length;

    for(int i = 0; i < length; i++)
    {
        *alloc_use_end++ = **src;
        *src = *src + 1;
    }

    *alloc_use_end = 0;
}

void VFILE::skip_to_punc(char **ptr, char value)
{
    char *temp = *ptr;

    while(*temp++ != value)
        *ptr = *ptr + 1;

    *ptr = *ptr + 1;
}

int VFILE::is_line_end(char *ptr)
{
    char *temp = ptr;
    if(isblank(*temp) && isblank(*(temp+1)))
        return 1;
    return 0;
}

void VFILE::parse_file(void)
{
    pool_last = 300;  
    str_new(&alloc_pool, pool_last + 1);
    *alloc_pool = 0;
    alloc_use_end = alloc_pool;


    char *temp = NULL;
    str_new(&temp, 300);
    char *temp_start = temp;
    for(unsigned int line = start_line + 1; line <= end_line; line++)
    {
        infile.getline(temp, 300);
        skip_blank(&temp);
        skip_to_punc(&temp,':');

        do
        {
            skip_blank(&temp);
            copy_to_blank(&temp);

            if(*temp == 0 || *(temp + 1) == 0)
                break;
            if(*temp == '\n' || *(temp + 1) == '\n')
                break;

        }while(!is_line_end(temp));
    }

    delete[]temp_start;
    temp = NULL;
}

void VFILE::format_alloc(void)
{
    unsigned int alloc_used = alloc_use_end - alloc_pool;
    alloc_use_end = alloc_pool;
    int add_line= (alloc_used / 8);

    char *temp = NULL;
    str_new (&temp, alloc_used + add_line * 11 + 2);     
    *temp = 0;
    *(temp + alloc_used + add_line * 11 ) = '\n';
    *(temp + alloc_used + add_line * 11 + 1) = 0;

    int label = start_label;

    for(int i = 0; i < add_line; i++)
    {
        char *str_label = NULL;
        str_new(&str_label, 32);
        *str_label = 0;
        int_to_str(str_label, label, 16);

        strcat(temp, " ");
        strcat(temp,str_label);
        strcat(temp,":\t");

        {
            char str_array[8];

            for(int k = 3; k >=0; --k)
            {
                ((short*)str_array)[3-k] = ((short*)alloc_use_end)[k];
            }
            strncpy(str_label, str_array, 8);
        }
        alloc_use_end += 8;
        *(str_label + 8) = '\n';
        *(str_label + 9) = 0;

        strcat(temp, str_label);
        delete[]str_label;

        label = label + 4;
    }

    delete[]alloc_pool;
    alloc_pool = temp;
}         
void VFILE::parse_write(void)
{
    outfile_write();
}

void VFILE::last_write(void)
{
    str_new(&alloc_pool, 300);
    file_fix_changed(0);
    delete[]alloc_pool;
    alloc_pool = NULL;

}