src/ilasm/asmman.hpp

   1 //
   2 // Copyright (c) Microsoft. All rights reserved.
   3 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
   4 //
   5 //
   6 // asmman.hpp - header file for manifest-related ILASM functions
   7 //
   8
   9 #ifndef ASMMAN_HPP
  10 #define ASMMAN_HPP
  11
  12 #include "strongname.h"
  13 #ifndef FEATURE_CORECLR
  14 #include "LegacyActivationShim.h"
  15 #endif
  16 #include "specstrings.h"
  17
  18 struct AsmManFile
  19 {
  20     char*   szName;
  21     mdToken tkTok;
  22     DWORD   dwAttr;
  23     BinStr* pHash;
  24     BOOL    m_fNew;
  25     CustomDescrList m_CustomDescrList;
  26     AsmManFile()
  27     {
  28         szName = NULL;
  29         pHash = NULL;
  30         m_fNew = TRUE;
  31     }
  32     ~AsmManFile()
  33     {
  34         if(szName)  delete szName;
  35         if(pHash)   delete pHash;
  36     }
  37     int ComparedTo(AsmManFile* pX){ return strcmp(szName,pX->szName); }
  38 };
  39 //typedef SORTEDARRAY<AsmManFile> AsmManFileList;
  40 typedef FIFO<AsmManFile> AsmManFileList;
  41
  42 struct AsmManAssembly
  43 {
  44         BOOL    isRef;
  45         BOOL    isAutodetect;
  46         char*   szName;
  47         char*   szAlias;
  48     DWORD   dwAlias;
  49         mdToken tkTok;
  50         DWORD   dwAttr;
  51         BinStr* pPublicKey;
  52         BinStr* pPublicKeyToken;
  53         ULONG   ulHashAlgorithm;
  54         BinStr* pHashBlob;
  55         BinStr* pLocale;
  56     BOOL    m_fNew;
  57     // Security attributes
  58     PermissionDecl* m_pPermissions;
  59     PermissionSetDecl* m_pPermissionSets;
  60         CustomDescrList m_CustomDescrList;
  61         USHORT  usVerMajor;
  62         USHORT  usVerMinor;
  63         USHORT  usBuild;
  64         USHORT  usRevision;
  65     AsmManAssembly()
  66     {
  67     /*
  68         usVerMajor = usVerMinor = usBuild = usRevision = 0xFFFF;
  69         szName = szAlias = NULL;
  70         dwAlias = dwAttr = 0;
  71         tkTok = 0;
  72         pPublicKey = pPublicKeyToken =pHashBlob = pLocale = NULL;
  73         ulHashAlgorithm = 0;
  74         m_fNew = TRUE;
  75         isAutodetect = isRef = FALSE;
  76     */
  77     }
  78         ~AsmManAssembly()
  79         {
  80                 if(szAlias && (szAlias != szName)) delete [] szAlias;
  81                 if(szName) delete [] szName;
  82                 if(pPublicKey) delete pPublicKey;
  83                 if(pPublicKeyToken) delete pPublicKeyToken;
  84                 if(pHashBlob) delete pHashBlob;
  85                 if(pLocale) delete pLocale;
  86         }
  87     int ComparedTo(AsmManAssembly* pX){ return strcmp(szAlias,pX->szAlias); }
  88 };
  89 //typedef SORTEDARRAY<AsmManAssembly> AsmManAssemblyList;
  90 typedef FIFO<AsmManAssembly> AsmManAssemblyList;
  91
  92 struct AsmManComType
  93 {
  94     char*   szName;
  95     mdToken tkTok;
  96     mdToken tkImpl;
  97     DWORD   dwAttr;
  98     char*   szFileName;
  99     char*   szAsmRefName;
 100     char*   szComTypeName;
 101     mdToken tkClass;
 102     BOOL    m_fNew;
 103     CustomDescrList m_CustomDescrList;
 104     AsmManComType()
 105     {
 106         szName = szFileName = szAsmRefName = szComTypeName = NULL;
 107         m_fNew = TRUE;
 108         tkImpl = 0;
 109     };
 110     ~AsmManComType()
 111     {
 112         if(szName) delete szName;
 113         if(szFileName) delete szFileName;
 114     };
 115     int ComparedTo(AsmManComType* pX){ return strcmp(szName,pX->szName); };
 116 };
 117 //typedef SORTEDARRAY<AsmManComType> AsmManComTypeList;
 118 typedef FIFO<AsmManComType> AsmManComTypeList;
 119
 120
 121 struct AsmManRes
 122 {
 123         char*   szName;
 124     char*   szAlias;
 125         mdToken tkTok;
 126         DWORD   dwAttr;
 127         char*   szFileName;
 128         ULONG   ulOffset;
 129     BOOL    m_fNew;
 130         CustomDescrList m_CustomDescrList;
 131         char*   szAsmRefName;
 132         AsmManRes() { szName = szAlias = szAsmRefName = szFileName = NULL; ulOffset = 0; tkTok = 0; dwAttr = 0; m_fNew = TRUE; };
 133         ~AsmManRes()
 134         {
 135         if(szAlias && (szAlias != szName)) delete szAlias;
 136                 if(szName) delete szName;
 137                 if(szFileName) delete szFileName;
 138                 if(szAsmRefName) delete szAsmRefName;
 139         }
 140 };
 141 typedef FIFO<AsmManRes> AsmManResList;
 142
 143 struct AsmManModRef
 144 {
 145     char*   szName;
 146     mdToken tkTok;
 147     BOOL    m_fNew;
 148     AsmManModRef() {szName = NULL; tkTok = 0; m_fNew = TRUE; };
 149     ~AsmManModRef() { if(szName) delete szName; };
 150 };
 151 typedef FIFO<AsmManModRef> AsmManModRefList;
 152
 153 struct AsmManStrongName
 154 {
 155     enum AllocationState
 156     {
 157         NotAllocated = 0,
 158         AllocatedBySNApi,
 159         AllocatedByNew
 160     };
 161
 162     BYTE *m_pbSignatureKey;
 163     DWORD m_cbSignatureKey;
 164     BYTE   *m_pbPublicKey;
 165     DWORD   m_cbPublicKey;
 166     BYTE   *m_pbPrivateKey;
 167     DWORD   m_cbPrivateKey;
 168     WCHAR  *m_wzKeyContainer;
 169     BOOL    m_fFullSign;
 170
 171     // Where has the memory pointed to by m_pbPublicKey been taken from:
 172     AllocationState   m_dwPublicKeyAllocated;
 173
 174     AsmManStrongName() { ZeroMemory(this, sizeof(*this)); }
 175     ~AsmManStrongName()
 176     {
 177 #ifndef FEATURE_CORECLR
 178         if (m_dwPublicKeyAllocated == AllocatedBySNApi)
 179         {
 180             LegacyActivationShim::StrongNameFreeBuffer(m_pbPublicKey);
 181         }
 182         else
 183 #endif
 184         if (m_dwPublicKeyAllocated == AllocatedByNew)
 185             delete [] m_pbPublicKey;
 186
 187         if (m_pbPrivateKey)
 188             delete [] m_pbPrivateKey;
 189
 190         if (m_pbSignatureKey)
 191             delete [] m_pbSignatureKey;
 192     }
 193 };
 194
 195 class ErrorReporter;
 196
 197 class AsmMan
 198 {
 199     AsmManFileList      m_FileLst;
 200     AsmManComTypeList   m_ComTypeLst;
 201     AsmManResList       m_ManResLst;
 202     AsmManModRefList    m_ModRefLst;
 203
 204     AsmManComType*      m_pCurComType;
 205     AsmManRes*          m_pCurManRes;
 206     ErrorReporter*      report;
 207     void*               m_pAssembler;
 208
 209     AsmManFile*         GetFileByName(__in __nullterminated char* szFileName);
 210     AsmManAssembly*     GetAsmRefByName(__in __nullterminated const char* szAsmRefName);
 211     AsmManComType*      GetComTypeByName(__in_opt __nullterminated char* szComTypeName,
 212                                          __in_opt __nullterminated char* szComEnclosingTypeName = NULL);
 213     mdToken             GetComTypeTokByName(__in_opt __nullterminated char* szComTypeName,
 214                                             __in_opt __nullterminated char* szComEnclosingTypeName = NULL);
 215
 216     IMetaDataEmit*          m_pEmitter;
 217
 218 public:
 219     IMetaDataAssemblyEmit*  m_pAsmEmitter;
 220     AsmManAssemblyList  m_AsmRefLst;
 221     AsmManAssembly*     m_pAssembly;
 222     AsmManAssembly*     m_pCurAsmRef;
 223     char*   m_szScopeName;
 224     BinStr* m_pGUID;
 225     AsmManStrongName    m_sStrongName;
 226         // Embedded manifest resources paraphernalia:
 227     WCHAR*  m_wzMResName[MAX_MANIFEST_RESOURCES];
 228         DWORD   m_dwMResSize[MAX_MANIFEST_RESOURCES];
 229     BOOL    m_fMResNew[MAX_MANIFEST_RESOURCES];
 230         DWORD   m_dwMResNum;
 231         DWORD   m_dwMResSizeTotal;
 232         AsmMan() { m_pAssembly = NULL; m_szScopeName = NULL; m_pGUID = NULL; m_pAsmEmitter = NULL;
 233                                 memset(m_wzMResName,0,sizeof(m_wzMResName));
 234                                 memset(m_dwMResSize,0,sizeof(m_dwMResSize));
 235                                 m_dwMResNum = m_dwMResSizeTotal = 0; };
 236         AsmMan(void* pAsm) { m_pAssembly = NULL; m_szScopeName = NULL; m_pGUID = NULL; m_pAssembler = pAsm;  m_pAsmEmitter = NULL;
 237                                 memset(m_wzMResName,0,sizeof(m_wzMResName));
 238                                 memset(m_dwMResSize,0,sizeof(m_dwMResSize));
 239                                 m_dwMResNum = m_dwMResSizeTotal = 0; };
 240         AsmMan(ErrorReporter* rpt) { m_pAssembly = NULL; m_szScopeName = NULL; m_pGUID = NULL; report = rpt;  m_pAsmEmitter = NULL;
 241                                 memset(m_wzMResName,0,sizeof(m_wzMResName));
 242                                 memset(m_dwMResSize,0,sizeof(m_dwMResSize));
 243                                 m_dwMResNum = m_dwMResSizeTotal = 0; };
 244         ~AsmMan()
 245         {
 246                 if(m_pAssembly) delete m_pAssembly;
 247                 if(m_szScopeName) delete m_szScopeName;
 248                 if(m_pGUID) delete m_pGUID;
 249         };
 250         void    SetErrorReporter(ErrorReporter* rpt) { report = rpt; };
 251         HRESULT EmitManifest(void);
 252
 253     void    SetEmitter( IMetaDataEmit* pEmitter) { m_pEmitter = pEmitter; };
 254
 255     void    SetModuleName(__inout_opt __nullterminated char* szName);
 256
 257     void    AddFile(__in __nullterminated char* szName, DWORD dwAttr, BinStr* pHashBlob);
 258     void    EmitFiles();
 259         void    EmitDebuggableAttribute(mdToken tkOwner);
 260
 261         void    StartAssembly(__in __nullterminated char* szName, __in_opt __nullterminated char* szAlias, DWORD dwAttr, BOOL isRef);
 262         void    EndAssembly();
 263     void    EmitAssemblyRefs();
 264     void    EmitAssembly();
 265         void    SetAssemblyPublicKey(BinStr* pPublicKey);
 266         void    SetAssemblyPublicKeyToken(BinStr* pPublicKeyToken);
 267         void    SetAssemblyHashAlg(ULONG ulAlgID);
 268         void    SetAssemblyVer(USHORT usMajor, USHORT usMinor, USHORT usBuild, USHORT usRevision);
 269         void    SetAssemblyLocale(BinStr* pLocale, BOOL bConvertToUnicode);
 270         void    SetAssemblyHashBlob(BinStr* pHashBlob);
 271     void    SetAssemblyAutodetect();
 272
 273     void    StartComType(__in __nullterminated char* szName, DWORD dwAttr);
 274     void    EndComType();
 275     void    SetComTypeFile(__in __nullterminated char* szFileName);
 276     void    SetComTypeAsmRef(__in __nullterminated char* szAsmRefName);
 277     void    SetComTypeComType(__in __nullterminated char* szComTypeName);
 278     BOOL    SetComTypeImplementationTok(mdToken tk);
 279     BOOL    SetComTypeClassTok(mdToken tkClass);
 280
 281     void    StartManifestRes(__in __nullterminated char* szName, __in __nullterminated char* szAlias, DWORD dwAttr);
 282     void    EndManifestRes();
 283     void    SetManifestResFile(__in __nullterminated char* szFileName, ULONG ulOffset);
 284     void    SetManifestResAsmRef(__in __nullterminated char* szAsmRefName);
 285
 286     mdToken             GetFileTokByName(__in __nullterminated char* szFileName);
 287     mdToken             GetAsmRefTokByName(__in __nullterminated const char* szAsmRefName);
 288     mdToken             GetAsmTokByName(__in __nullterminated const char* szAsmName)
 289         { return (m_pAssembly && (strcmp(m_pAssembly->szName,szAsmName)==0)) ? m_pAssembly->tkTok : 0; };
 290
 291     mdToken GetModuleRefTokByName(__in __nullterminated char* szName)
 292     {
 293         if(szName && *szName)
 294         {
 295             AsmManModRef* pMR;
 296             for(unsigned i=0; (pMR=m_ModRefLst.PEEK(i)); i++)
 297             {
 298                 if(!strcmp(szName, pMR->szName)) return pMR->tkTok;
 299             }
 300         }
 301         return 0;
 302     };
 303
 304 };
 305
 306 #endif