gcc 汇编示例 - vfdff的博客

vfdff(作者)

2010-08-18 13:19

1

#include <asm/page.h> 
#include <sys/mman.h> 
typedef int (*FUNCPTR)(...); 
FUNCPTR newFuncList[MAX_FUNC_NUM] = {NULL}; // MAX_FUNC_NUM在TmpReplaceFunc.h中定义赋值 
FUNCPTR oldFuncList[MAX_FUNC_NUM] = {NULL}; 
BYTE g_aucOldFuncInstruct[MAX_FUNC_NUM][6] = {{0}}; 
int Ulong2ByteArr(BYTE* pucDest, ULONG ulSrc) 
{ 
    // 要考虑大小字节序 
    *pucDest = (BYTE)(ulSrc & 0XFF); 
    *(pucDest + 1) = (BYTE)((ulSrc & 0XFF00) >> 8); 
    *(pucDest + 2) = (BYTE)((ulSrc & 0XFF0000) >> 16); 
    *(pucDest + 3) = (BYTE)((ulSrc & 0XFF000000) >> 24); 
 
    return 0; 
} 
 
unsigned int ChangeProtection(const unsigned int ulAddr, const unsigned int ulLength, const unsigned int ulMode ) 
{ 
    int iRtn; 
    unsigned int ulLastPageEnd; 
    unsigned int ulFirstPageStart; 
 
    /* Find the start address of the page to which the adress belongs to */ 
    ulFirstPageStart = ulAddr - (ulAddr % 4096); 
 
    ulLastPageEnd  = ulAddr + ulLength; 
    ulLastPageEnd += 4096 - (ulLastPageEnd % 4096); 
 
    iRtn = mprotect((void*)ulFirstPageStart, ulLastPageEnd - ulFirstPageStart, ulMode ); 
    //iRtn = mprotect((void*)ulFirstPageStart, 4096, ulMode ); 
    if (0 != iRtn) 
    { 
        printf("\r\nCall mprotect fail!\n"); 
        return FALSE; 
    } 
 
    return TRUE; 
} 
unsigned int ModProtectMemContent(unsigned long*  pBaseAddress, \ 
                                  const BYTE* pucInstruContent, unsigned long ulInstruLen) 
{ 
    //BYTE aBuf[10]; 
 
    if (ChangeProtection((const unsigned int)pBaseAddress, ulInstruLen, PROT_WRITE | PROT_READ | PROT_EXEC) == FALSE) 
    { 
        return FALSE; 
    } 
 
    // 修改老函数入口处的指令，用上面准备的跳转指令修改 
    (void)memcpy(pBaseAddress, pucInstruContent, ulInstruLen); 
 
    if (ChangeProtection((const unsigned int)pBaseAddress, ulInstruLen, PROT_READ | PROT_EXEC) == FALSE) 
    { 
        return FALSE; 
    } 
 
    return TRUE; 
} 
 
//====================================================== 
 
/* 
   函数名称：ReadProcessMemExt 
   功能：    完成获取进程内容的功能，是对ReadProcessMemory的扩展 
   参数： 
        [in]   hProcess，进程句柄 
        [in]   pBaseAddress，待写内存开始地址 
        [in]   ulInstruLen,  要读取的内容的长度 
        [out]   pucInstruContent，保存读到的内容 
 
   返回值：成功返回TRUE，失败返回FALSE 
*/ 
unsigned int ReadProcessMemExt(unsigned long*  pBaseAddress, \ 
                               unsigned long ulInstruLen, BYTE* pucInstruContent) 
{ 
    //BYTE aBuf[10]; 
 
    if (ChangeProtection((const unsigned int)pBaseAddress, ulInstruLen, PROT_WRITE | PROT_READ | PROT_EXEC) == FALSE) 
    { 
        return FALSE; 
    } 
 
    // 获取指定内存的内容 
    (void)memcpy(pucInstruContent, pBaseAddress, ulInstruLen); 
 
    if (ChangeProtection((const unsigned int)pBaseAddress, ulInstruLen, PROT_READ | PROT_EXEC) == FALSE) 
    { 
        return FALSE; 
    } 
 
    return TRUE; 
}

赞回复

vfdff(作者)

2010-08-19 21:20

2

BYTE aBuf[10]; 
 
    //printf("Input pOldFunc = 0x%x, pNewFunc = 0x%x!\n", pOldFunc, pNewFunc); 
 
    // 说明：由于函数地址在保护区域，不能用普通的修改内存值的方式实现， 
    //       只能通过系统函数，来改变某个进程的内存内容方式实现 
 
    // 先得到原函数调用地址的跳转偏移，为下面计算相对偏移做准备 
 
    // 将新函数指针和原函数调用地址保存到列表中 
    for (i = 0; i < MAX_FUNC_NUM; i++) 
    { 
        if (newFuncList == NULL) 
        { 
            break; 
        } 
    } // end for i 
 
    if (i >= MAX_FUNC_NUM) 
    { 
        printf("\r\nThe new func list is full!\n"); 
        return 1; 
    } 
 
    // 获取原函数开始的一段指令 
 
    iTmpLen = GetInstructionLen((BYTE*)pOldFunc); 
    if (0 == iTmpLen) 
    { 
        printf("\r\nGen first Instruction length fail!\n"); 
        return 1; 
    } 
    else if (iTmpLen >= 5) // >=要插入的跳转指令的长度，只需记录指令长度即可 
    { 
        iInstruLen = iTmpLen; 
    } 
    else 
    { 
        iInstruLen = iTmpLen; 
        while (iInstruLen < 5) 
        { 
            iTmpLen = GetInstructionLen((BYTE*)pOldFunc + iInstruLen); 
            if (0 == iTmpLen) 
            { 
                printf("\r\nGen other Instruction length fail!\n"); 
                return 1; 
            } 
 
            iInstruLen += iTmpLen; 
        } 
    } 
    printf("\r\nThe new func list is %d,!\n", iInstruLen);

赞回复

vfdff(作者)

2010-08-22 20:25

3

int puts(char *buf) 
{ 
        return 0; 
} 
 
int main(void) 
{ 
  char *str="Hello, Gcc Inline Assembly World!n"; 
 
  puts(str); 
 
  return 0; 
} 
发现定义一个和库函数同名的函数，则库函数被隐藏，并且不提示函数冲突错误

赞回复

vfdff(作者)

2010-11-10 12:57

4

// 找出只包含ModR/M，不包含立即数的指令操作码 
        x00:         // LLDT/LTR/SLDT/STR/VERR/VERW 
        x01:         // INVLPG/LGDT/LIDT/LMSW/SGDT/SIDT/SMSW/SMSW 
        x02:         // LAR 
        x03:         // LSL 
        x20: 
        x21: 
        x22: 
        x23:                                          // MOV (new) 
        x40:         // CMOVO (new) 
        x41:         // CMOVNO (new) 
        x42:         // CMOVB/CMOVC/CMOVNAE (new) 
        x43:         // CMOVNB/CMOVNC/CMOVAE (new) 
        x44:         // CMOVE/CMOVZ (new) 
        x45:         // CMOVNE/CMOVNZ (new) 
        x46:         // CMOVBE/CMOVNA (new) 
        x47:         // CMOVNBE/CMOVA (new) 
        x48:         // CMOVS (new) 
        x49:         // CMOVNS (new) 
        x4A:         // CMOVP/CMOVPE (new) 
        x4B:         // CMOVNP/CMOVPO (new) 
        x4C:         // CMOVL/CMOVNGE (new) 
        x4D:         // CMOVNL/CMOVGE (new) 
        x4E:         // CMOVLE/CMOVNG (new) 
        x4F:         // CMOVNLE/CMOVG (new) 
        x60:         // PUNPCKLBW (new) 
        x61:         // PUNPCKLWD (new) 
        x62:         // PUNPCKLDQ (new) 
        x63:         // PACKSSWB  (new) 
        x64:         // PCMPGTB   (new) 
        x65:         // PCMPGTW   (new) 
        x66:         // PCMPGTD  (new) 
        x67:         // PACKUSWB (new) 
        x68:         // PUNPCKHBW(new) 
        x69:         // PUNPCKHWD(new) 
        x6A:         // PUNPCKHDQ(new) 
        x6B:         // PACKSSDW (new) 
        x6E:         // MOVD     (new) 
        x6F:         // MOVQ     (new) 
        x74:         // PCMPEQB  (new) 
        x75:         // PCMPEQW  (new) 
        x76:         // PCMPEQD  (new) 
        x7E:         // MOVD     (new) 
        x7F:         // MOVQ     (new) 
        x90:         // SETO 
        x91:         // SETNO 
        x92:         // SETB/SETC/SETNAE 
        x93:         // SETAE/SETNB/SETNC 
        x94:         // SETE/SETZ 
        x95:         // SETNE/SETNZ 
        x96:         // SETBE/SETNA 
        x97:         // SETNBE/SETA 
        x98:         // SETS 
        x99:         // SETNS 
        x9A:         // SETP/SETPE 
        x9B:         // SETNP/SETPO 
        x9C:         // SETL/SETNGE 
        x9D:         // SETNL/SETGE 
        x9E:         // SETLE/SETNG 
        x9F:         // SETNLE/SETG 
        xA3:         // BT 
        xA5:         // SHLD 
        xAB:         // BTS 
        xAD:         // SHRD 
        xAF:         // IMUL 
        xB0: 
        xB1:                    // CMPXCHG 
        xB2:         // LSS 
        xB3:         // BTR 
        xB4:         // LFS 
        xB5:         // LGS 
        xB6: 
        xB7:                    // MOVZX 
        xBB:         // BTC 
        xBC:         // BSF 
        xBD:         // BSR 
        xBE: 
        xBF:                    // MOVSX 
        xC0: 
        xC1:                    // XADD 
        xD1:         // PSRLW (new) 
        xD2:         // PSRLD (new) 
        xD3:         // PSRLQ (new) 
        xD5:         // PMULLW (new) 
        xD8:         // PSUBUSB (new) 
        xD9:         // PSUBUSW (new) 
        xDB:         // PAND (new) 
        xDC:         // PADDUSB (new) 
        xDD:         // PADDUSW (new) 
        xDF:         // PANDN (new) 
        xE1:         // PSRAW (new) 
        xE2:         // PSRAD (new) 
        xE5:         // PMULHW (new) 
        xE8:         // PSUBSB (new) 
        xE9:         // PSUBSW (new) 
        xEB:         // POR (new) 
        xEC:         // PADDSB (new) 
        xED:         // PADDSW (new) 
        xEF:         // PXOR (new) 
        xF1:         // PSLLW (new) 
        xF2:         // PSLLD (new) 
        xF3:         // PSLLQ (new) 
        xF5:         // PMADDWD (new) 
        xF8:         // PSUBB (new) 
        xF9:         // PSUBW (new) 
        xFA:         // PSUBD (new) 
        xFC:         // PADDB (new) 
        xFD:         // PADDW (new) 
        xFE:         // PADDD (new) 
            ulAnlysFlag |= FLAG_MOD_RM; 
            break;

赞回复

vfdff(作者)

2010-11-10 12:58

5

//----------------------------------------------- 
            // 找出包含ModR/M和操作数为一字节立即数的指令操作码 
        x71:         // PSLLW/PSRAW/PSRLW (new) 
        x72:         // PSLLD/PSRAD/PSRLD (new) 
        x73:         // PSLLQ/PSRLQ  (new) 
        xA4:         // SHLD 
        xAC:         // SHRD 
        xBA:         // BT/BTC/BTR/BTS 
            ulDataLen++; 
            ulAnlysFlag |= FLAG_MOD_RM; 
            break;

赞回复

vfdff(作者)

2010-11-10 13:00

6

//------------------------------------------------ 
        // 找出包含ModR/M和操作数为默认长度立即数的指令操作码 
        case 0x80:         // JO (new) 
        case 0x81:         // JNO (new) 
        case 0x82:         // JB/JC/JNAE (new) 
        case 0x83:         // JAE/JNB/JNC (new) 
        case 0x84:         // JE/JZ (new) 
        case 0x85:         // JNE/JNZ (new) 
        case 0x86:         // JBE/JNA (new) 
        case 0x87:         // JA/JNBE (new) 
        case 0x88:         // JS (new) 
        case 0x89:         // JNS (new) 
        case 0x8A:         // JP/JPE (new) 
        case 0x8B:         // JNP/JPO (new) 
        case 0x8C:         // JL/JNGE (new) 
        case 0x8D:         // JGE/JNL (new) 
        case 0x8E:         // JLE/JNG (new) 
        case 0x8F:         // JG/JNLE (new) 
            ulDataLen += ulDefOprdSize; 
            break; 
            //----------------------------------------------- 
        // 对CMPXCHG8B指令特殊处理 
        case 0xC7:         // CMPXCHG8B 
            ulDataLen++; 
            break; 
 
            //---------------------------------- 
        default: 
            InfoOutput("\r\n[EXPT]The second opcode is 0x%X when first opcode is 0x0F, not support!", ucOpcode2); 
            return 0;        // 0F 第二个操作码为其他取值的，认为出错了，返回0 
        }     // 0F-switch 
        break; 
 
        // 目前不支持操作码为82/D6/F1的指令，如果出现了，说明出现异常 
    case 0x82: 
    case 0xD6: 
    case 0xF1: 
        InfoOutput("\r\n[EXPT]The Opcode is 0x%X, not support!", ucOpcode); 
        return 0; 
    } //switch 
 
    if (ulAnlysFlag & FLAG_MOD_RM) 
    { 
        // 得到ModR/M字节的内容 
        ucModRM = *pucTmpInstruAddr++; 
 
        /* 
            ModR/M字节的结构如下： 
         +----+------+------+ 
         |mod | reg2 | reg1 | 
         +----+------+------+ 
         */ 
        ucMod = ucModRM & 0xC0; // 得到ModR/M字节mod域的取值 
        ucRM = ucModRM & 0x07; // 得到ModR/M字节reg1域的取值 
 
        if (ucMod != 0xC0) // 后续的为内存地址而非寄存器 
        { 
            if (ucMod == 0x40) // mod = 01, 则后面用一字节的空间来存放偏移 
            { 
                ulAddrLen++; 
            } 
            else if (ucMod == 0x80) // mod = 10, 则后面用一个机器字（即默认地址长度）的空间来存放偏移 
            { 
                ulAddrLen += ulDefAddrSize; 
            } 
 
            if (ulDefAddrSize == 2) // modrm16 
            { 
                if ((ucMod == 0x00) && (ucRM == 0x06)) // mod = 00, reg1 = 6，且为16bit模式，后面用2个字节来保存偏移 
                { 
                    ulAddrLen += 2; 
                } 
            } 
            else // modrm32 
            { 
                if (ucRM == 0x04) 
                { 
                    ulAnlysFlag |= FLAG_SIB; 
                    ucSIB = *pucTmpInstruAddr++; 
                } 
                else if ((ucRM == 0x05) && (ucMod == 0x00)) // mod = 00, reg1 = 5，且为32bit模式，后面用4个字节来保存偏移 
                { 
                    ulAddrLen += 4; 
                } 
            } 
        } // end of if(ucMod != 0xC0) 
    } // end of if(ulAnlysFlag & FLAG_MOD_RM) 
 
    // 得到指令的长度 
    iInstruLen  = pucTmpInstruAddr - pucInstruAddr; 
    iInstruLen += ulAddrLen; 
    iInstruLen += ulDataLen; 
 
    return iInstruLen; 
} // end of func GetInstructionLen

赞回复

vfdff(作者)

2010-11-11 00:11

7

gcc 内嵌汇编的编码示例 
 
Linux 内核源代码中，许多C 代码中嵌入了汇编语句，这是通过关键字asm 来实现的。 
 
它的形式如下所示： 
 
                               代码片段2.6 gcc 内嵌汇编示例 
-------------------------------------------------------------------------------------------- 
 
1 static inline unsigned long native_read_cr2(void) 
2 { 
3 unsigned long val; 
4 asm volatile("movl %%cr2,%0\n\t" :"=r" (val)); 
5 return val; 
6 } 
 
         其中asm 表示汇编指令的开始，由于gcc 在编译优化阶段，可能会调整指令的顺序，关键字volatile 阻止gcc 对这里的内嵌汇编指令进行优化。另外在内核代码中常常还看到__asm__，__volatile__，它们的作用和asm，volatile 是一样的，为什么要两个作用相同的关键字呢？这是由于在C 标准制定之初，并没有asm 和volatile 这两个关键字，后来由于实际需要，加入了这两个关键字时，考虑到已有的C 代码中，可能存在变量名为asm 或volatile 的情况，为了兼容这种情况，所以又加入了__asm__ 和__volatile__ 这两个关键字。 
 
        gcc 内嵌汇编的通用形式如下所示： 
 
            代码片段2.7 Intel 与AT&T 汇编格式比较 
-------------------------------------------------------------------------------------------- 
 
1 asm volatile (assembler template : output : input: clobber); 
 
        其中assembler template 为汇编指令部分，例如上例中的"movl %%cr2, %0"。output 是输出部分，input 表示输入部分，clobber 表示被修改的部分。汇编指令中的数字和前缀%表示样板操作数，例如%0，%1 等，用来依次指代后面的输出部分，输入部分等样板操作数。 
 
        由于这些样板操作数使用了%，因此寄存器前面要加两个%，例如上例中的%%cr2。ouput 和input 分别是输出部分和输入部分，clobber 是损坏部分。 
 
        为什么要这样呢？这是由于汇编指令中常常需要使用寄存器，但是寄存器是由gcc 在编译时分配的，由于访问寄存器要比访问内存快，因此当gcc 对一个代码块进行优化时，通常把空闲的寄存器分配给被频繁访问的变量。假设有以下代码块： 
 
                代码片段2.8 C 代码示例 
-------------------------------------------------------------------------------------------- 
 
1 int f() 
2 { 
3 .... 
4 int i; 
5 int total = 0; 
6 for (i = 0; i < 100; i++) { 
7 
8 
9 
10 
11 
total += i; 
        } 
... 
return total; 
} 
 
        在上面的代码块中，i 和total 都是被频繁访问的变量，因此gcc 可能会为它们分配两个空闲的寄存器，例如把EAX 和ECX 分别分配给i 和total，这样在整个for 循环只需要对寄存器进行操作。如果在for 循环之前所有的寄存器已经分配出去了，此时就没有空闲的寄存器，gcc 可能需要插入一条指令把某个寄存器的值写回到对应的内存变量中(和前面的EAX 对应于堆栈中的一个内存变量i 是一样的道理)，然后再把这个寄存器分配给变量i。需要注意的是，这里讨论的是有这种可能。因此程序员在任何时候都不知道哪个寄存器是空闲的。 
 
        我们再来看一个例子，汇编指令bts n, ADDR ，可以把地址为ADDR 的内存单元的第n 位设置为1。其中ADDR 是一个内存变量，而n 必须是立即数或寄存器。如果要在C 代码中之间嵌入这条汇编指令，而n 是通过计算得到的结果(n 不是立即数)，这时就需要腾出一个寄存器来。而程序员不能预测到gcc 在编译时对寄存器的分配情况，所以gcc 的内嵌汇编提供一个模板，用来指导gcc 该如何处理。下面是在C 代码中内嵌btsl 指令的示例。 
 
              代码片段2.9 gcc 内嵌汇编代码示例 
-------------------------------------------------------------------------------------------- 
 
1 static inline void set_bit(int nr, void *addr) 
2 { 
3 asm("btsl %1,%0" : "+m" (*(u32 *)addr) : "Ir" (nr)); 
4 } 
 
 
        在这个例子中输出部分为addr，输入部分为nr，没有损坏部分。修饰符"+m"限定指针addr 指向一个可读写的内存单元，"Ir"指定nr 必须是一个立即数，或者是一个寄存器变量。 
 
 
        当某段代码调用set_bit()函数时，如果参数nr 是一个立即数或者是一个寄存器，那么就满足这个限制条件。但是如果调用set_bit()函数时传递的参数nr 在内存中，这时候gcc 必须分配一个寄存器，并且插入一条指令把内存中的值加载到这个寄存器中。如果没有空闲的寄存器，那么gcc 就要插入一条指令把某个寄存器保存到对应的内存中，腾出这个寄存器来保存参数nr 的值，最后再插入一条指令恢复这个寄存器的值。 
 
        在指令部分中的%0 表示addr 对应的操作数，%1 表示nr 对应的操作数。现在假设某段代码调用set_bit()函数时传递的参数nr 内存变量，gcc 在代码生成阶段，生成类似下面这样的代码2： 
 
               代码片段2.10 汇编代码 
-------------------------------------------------------------------------------------------- 
 
1 # 腾出EAX 寄存器。 
 
   注意这个例子的目的是为了说明原理，实际试验时不一定能够得到一模一样的结果。 
 
2.2 gcc 内嵌汇编23 
2 pushl %eax; 
3 movl nr, %eax; 
4 
5 # 假设(ebp-8)就是指针addr 指向的内存单元地址。 
6 bts %eax, -8(ebp); 
7 
8 # 恢复EAX 寄存器。 
9 popl %eax 
 
        通过这个例子就可以理解gcc 内嵌汇编复杂的原因了，在理解这个例子后，再来看gcc 的内嵌汇编，也就简单得多了。在gcc 内嵌汇编中，常用的限制符如表2.1所示。 
 
         现在来看一个相对复杂的例子，代码片段2.11 gcc 内嵌汇编代码示例 
____________________________________________________________________ 
 
1 #define mov_blk(src, dest, numwords) 
2 __asm__ __volatile__ ( 
3 "cld\n\t" 
4 "rep\n\t" 
5 "movsl" 
6 : 
7 : "S" (src), "D" (dest), "c" (numwords) 
8 :"%ecx", "%esi", "%edi" 
9 ) 
 
         我们知道，串操作指令movs 可以把ESI 寄存器指向的内存块复制到EDI 指向的内存块中，复制的字节数由ECX 寄存器指定。所以执行rep movsl 之前需要初始化ESI,EDI 和ECX 寄存器，但是在上面这段代码的汇编指令部分中，并没有看到设置这几个寄存器的汇编指令。这是由gcc 自动完成的。 
 
        在输入参数部分"S"(src)指定参数src 必须保存到ESI 寄存器中，"D"(dest)指定参数dest 必须保存到EDI 中，"c"(numwords)指定参数numwords 必须保存到ECX 中。在gcc 的代码生成阶段，在调用mov_blk()这个宏的代码块中，如果参数src,dest,numwords 都没有分配到对应的寄存器中，那么gcc 在展开汇编指令部分最前面插入指令，保存相应的寄存器，并且把参数src,dest,numwords 复制到对应的寄存器中。如果在此之前正好某个参数已经被gcc 分配到对应的寄存器中，那么就不需要插入这样的汇编指令。 
 
         在损坏部分，"%ecx","%esi","%edi"说明在汇编指令部分会改变这几个寄存器的值，这样如果之前这几个寄存器被分配给其他的变量，在代码前面gcc 会插入汇编指令保存这几个寄存器，在代码的最后，gcc 又会插入代码恢复这几个寄存器的值。 
 
本文摘自《独辟蹊径品内核：Linux内核源代码导读》

赞回复