LLVM 是 Low Level Virtual Machine （低级虚拟机）的简称，这个库提供了与编译器相关的支持，可以作为多种语言编译器的后台来使用。能够进行程序语言的编译期优化、链接优化、在线编译优化、代码生成。

LLVM是构架编译器(compiler)的框架系统，以C++编写而成，用于优化以任意程序语言编写的程序的编译时间(compile-time)、链接时间(link-time)、运行时间(run-time)以及空闲时间(idle-time)，对开发者保持开放，并兼容已有脚本。

Xcode 4.4中LLVM compiler 4.0带来的Objective-C新语法特性

1.使用的方法代码放置的位置顺序无关，没在.h文件中声明的方法，有的时候如果方法不在前面，可能会有警告。新的编译器会先扫描代码中的方法然后在编译，方便很多。

2.@property对于使用Objective-C的程序员来说是相当熟悉的，property方便自动生成变量的getter 和setter。在.h文件中声明之后，还要在.m文件中加上@synthesize关键字，这样才能完成自动getter 和setter的过程。

比如说，我在.h文件中写了

@property (strong, nonatomic) NSDictionary *order;

我还要去对于的.m文件中写上

@synthesize order;

是不是感觉很多余啊？现在在语法新特性中不用写这行代码了，新版的编译器帮你实现这行代码。也是说，你在.h文件中声明order属性后，就可以直接在实现文件中使用该属性的getter和setter方法,编译器还会根据属性的可读和可写自动判断是否提供setter方法。智能多了。

3.更多新特性参考：http://lxmdrw.blog.163.com/blog/static/2771697120128195203370/

__unsafe_unretain、__strong、__weak、__autoreleasing是出现在 LLVM 编译器 3.0版本之后。而__unsafe_unretain、__strong、__autoreleasing可以在不使用ARC（自动参考计数）可用。在ARC下，默认的指针都是__strong属性。这意味着一个对象赋值给另外一个指针，那么只要指针参考了该对象，该对象就会一直保持。这对于大部分对象都实用，但是这可能会导致retain cycle。例如，你拥有一个对象包含了另外了一个实例变量对象，但是第二个对象又把前一个对象作为它的委托，那么这两个对象将不会被释放。

因为上面的原因，所以才有了__unsafe_unretain和__weak限定符存在。他们通常用来修饰delegate，即定义一个delegate的属性时，使用__unsafe_unretain和__weak来修饰，然后通过使用__unsafe_unretain和__weak来单独标记实例变量。这意味着delegate实例变量将仍然能够指向第一个对象，但是它不会导致保留第一个对象，因此打破了retain cycle，而能够释放两个对象

除了delegate，__unsafe_unretain和__weak修饰符也还能避免你的代码出现retain cycle。Leaks instrument现在包含了一个cycle视图，能够发现你的应用中的retain cycle，并图像显示出来。

__unsafe_unretain和__weak都能避免retain cycle，但是他们也有一些细微的不同。对于__weak，当释放指针指向的对象时，该对象的指针将转换为nil，这是比较安全的行为。而__unsafe_unretain，正如其名称隐藏的含义，尽管释放指针指向的对象时，该指针将继续指向原来的内存。这将会导致应用crash，所以是unsafe。

为什么我们仍要使用__unsafe_unretain呢？这是因为__weak直到iOS5.0以及lion之后才出现。

而__autoreleasing 的英文解释为：to denote arguments that are passed by reference (id *) and are autoreleased on return，即主要是在引用传参时使用。 

#include <openssl/rsa.h>
#include <openssl/evp.h>
#pragma comment(lib, "libeay32.lib")

DWORD ReadBufferFromFile(LPCSTR lpFileName, PBYTE pBuffer, PDWORD pdwLength)
{
    if (NULL == lpFileName
        || NULL == pBuffer
        || NULL == pdwLength)
    {
        return -1;
    }

    //----------------------------
    // 0. Local variables declaration
    DWORD nbytes = 0;
    HANDLE hFile = NULL;
    DWORD dwBufferLen = *pdwLength;
    DWORD dwFileLen = 0;

    //----------------------------
    // 1. Read certificate to buff
    //    This certificate contains certificate info (CI) and digital signature (DS)
    hFile = CreateFileA(lpFileName, GENERIC_READ, 0, NULL,
        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );

    if (hFile == INVALID_HANDLE_VALUE) 
    {
        return -1;
    }

    dwFileLen = GetFileSize(hFile, NULL);
    *pdwLength = dwFileLen;

    if (dwBufferLen >= dwFileLen)
    {
        ReadFile(hFile, pBuffer, dwFileLen, &nbytes, NULL);
    }
    else
    {
        if (hFile != NULL)
        {
            CloseHandle(hFile);
        }

        return -1;
    }

    if (hFile != NULL)
    {
        CloseHandle(hFile);
    }

    return 0;
}

void FlipBuffer(unsigned char *pBuf, unsigned long ulLen)
{
    if(0 == ulLen)
    {
        return;
    }

    //char tmp;
    unsigned char ucTemp;
    for(unsigned long i = 0; i < ulLen >> 1; ++i)
    {
        ucTemp = pBuf[i];
        pBuf[i] = pBuf[ulLen - i - 1];
        pBuf[ulLen - i - 1] = ucTemp;
    }
}

void MSkeyConvertToOpenSSLKey(const char* filename, RSA& Rsa)
{
    if (NULL == filename)
    {
        return;
    }

    unsigned char byPrivateKeyBlob[2324] = {0};
    DWORD dwPrvKeySize = sizeof(byPrivateKeyBlob);
    ReadBufferFromFile(filename, byPrivateKeyBlob, &dwPrvKeySize);

    BYTE *pszPubBlob = byPrivateKeyBlob;
    RSAPUBKEY *rsapubkey = reinterpret_cast<RSAPUBKEY *>(pszPubBlob + sizeof(PUBLICKEYSTRUC));

    BYTE *pE = (BYTE *)&(rsapubkey->pubexp);
    DWORD dwElen = sizeof(DWORD);

    DWORD dwModulusLen = rsapubkey->bitlen / 8;
    DWORD dwPrimeLen = rsapubkey->bitlen/16;
    BYTE *pOffset = pszPubBlob + sizeof(BLOBHEADER) + sizeof(RSAPUBKEY);

    BYTE *pN = pOffset;
    pOffset += dwModulusLen;

    BYTE *pP = pOffset;
    pOffset += dwPrimeLen;

    BYTE *pQ = pOffset;
    pOffset += dwPrimeLen;

    BYTE *pP1 = pOffset;
    pOffset += dwPrimeLen;

    BYTE *pQ1 = pOffset;
    pOffset += dwPrimeLen;

    BYTE *pPQ = pOffset;
    pOffset += dwPrimeLen;

    BYTE *pD = pOffset;
    pOffset += dwModulusLen;

    FlipBuffer(pE, dwElen);
    FlipBuffer(pN, dwModulusLen);
    FlipBuffer(pP, dwPrimeLen);
    FlipBuffer(pQ, dwPrimeLen);
    FlipBuffer(pP1, dwPrimeLen);
    FlipBuffer(pQ1, dwPrimeLen);
    FlipBuffer(pPQ, dwPrimeLen);
    FlipBuffer(pD, dwModulusLen);

    while(0x00 == *pE)
    {
        pE = pE + 1;
        dwElen = dwElen - 1;
    }
    BIGNUM *pBE = BN_new();
    pBE = BN_bin2bn(pE, dwElen, pBE);

    BIGNUM *pBN = BN_new();
    pBN = BN_bin2bn(pN, dwModulusLen, pBN);

    BIGNUM *pBP = BN_new();
    pBP = BN_bin2bn(pP, dwPrimeLen, pBP);

    BIGNUM *pBQ = BN_new();
    pBQ = BN_bin2bn(pQ, dwPrimeLen, pBQ);

    BIGNUM *pBP1 = BN_new();
    pBP1 = BN_bin2bn(pP1, dwPrimeLen, pBP1);

    BIGNUM *pBQ1 = BN_new();
    pBQ1 = BN_bin2bn(pQ1, dwPrimeLen, pBQ1);

    BIGNUM *pBPQ = BN_new();
    pBPQ = BN_bin2bn(pPQ, dwPrimeLen, pBPQ);

    BIGNUM *pBD = BN_new();
    pBD = BN_bin2bn(pD, dwModulusLen, pBD);

    Rsa.n = pBN;
    Rsa.e = pBE;
    Rsa.p = pBP;
    Rsa.q = pBQ;
    Rsa.dmp1 = pBP1;
    Rsa.dmq1 = pBQ1;
    Rsa.iqmp = pBPQ;
    Rsa.d = pBD;
}

void OpenSSLGenFileHash()
{
    RSA* rsa = RSA_new();
    MSkeyConvertToOpenSSLKey("Test_1024_Key.prv", *rsa);

    const EVP_MD* algrothm = EVP_sha1();
    EVP_MD_CTX mdctx;
    EVP_MD_CTX_init(&mdctx);
    EVP_DigestInit_ex(&mdctx, algrothm, NULL);

    byte file[512] = {0};
    DWORD dwFileSize = sizeof(file);
    ReadBufferFromFile("PublicKey.bin", file, &dwFileSize);

    EVP_DigestUpdate(&mdctx, file, dwFileSize);

    BYTE signValue[128] = {0};
    UINT signLen = 0;
    EVP_DigestFinal_ex(&mdctx, signValue, &signLen);

    EVP_MD_CTX_cleanup(&mdctx);

    RSA_free(rsa);
}