1 //===-- WindowsResource.h ---------------------------------------*- C++-*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===---------------------------------------------------------------------===// 8 // 9 // This file declares the .res file class. .res files are intermediate 10 // products of the typical resource-compilation process on Windows. This 11 // process is as follows: 12 // 13 // .rc file(s) ---(rc.exe)---> .res file(s) ---(cvtres.exe)---> COFF file 14 // 15 // .rc files are human-readable scripts that list all resources a program uses. 16 // 17 // They are compiled into .res files, which are a list of the resources in 18 // binary form. 19 // 20 // Finally the data stored in the .res is compiled into a COFF file, where it 21 // is organized in a directory tree structure for optimized access by the 22 // program during runtime. 23 // 24 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/ms648007(v=vs.85).aspx 25 // 26 //===---------------------------------------------------------------------===// 27 28 #ifndef LLVM_INCLUDE_LLVM_OBJECT_RESFILE_H 29 #define LLVM_INCLUDE_LLVM_OBJECT_RESFILE_H 30 31 #include "llvm/ADT/ArrayRef.h" 32 #include "llvm/BinaryFormat/COFF.h" 33 #include "llvm/Object/Binary.h" 34 #include "llvm/Object/COFF.h" 35 #include "llvm/Object/Error.h" 36 #include "llvm/Support/BinaryByteStream.h" 37 #include "llvm/Support/BinaryStreamReader.h" 38 #include "llvm/Support/ConvertUTF.h" 39 #include "llvm/Support/Endian.h" 40 #include "llvm/Support/Error.h" 41 42 #include <map> 43 44 namespace llvm { 45 46 class raw_ostream; 47 class ScopedPrinter; 48 49 namespace object { 50 51 class WindowsResource; 52 class ResourceSectionRef; 53 54 const size_t WIN_RES_MAGIC_SIZE = 16; 55 const size_t WIN_RES_NULL_ENTRY_SIZE = 16; 56 const uint32_t WIN_RES_HEADER_ALIGNMENT = 4; 57 const uint32_t WIN_RES_DATA_ALIGNMENT = 4; 58 const uint16_t WIN_RES_PURE_MOVEABLE = 0x0030; 59 60 struct WinResHeaderPrefix { 61 support::ulittle32_t DataSize; 62 support::ulittle32_t HeaderSize; 63 }; 64 65 // Type and Name may each either be an integer ID or a string. This struct is 66 // only used in the case where they are both IDs. 67 struct WinResIDs { 68 uint16_t TypeFlag; 69 support::ulittle16_t TypeID; 70 uint16_t NameFlag; 71 support::ulittle16_t NameID; 72 setTypeWinResIDs73 void setType(uint16_t ID) { 74 TypeFlag = 0xffff; 75 TypeID = ID; 76 } 77 setNameWinResIDs78 void setName(uint16_t ID) { 79 NameFlag = 0xffff; 80 NameID = ID; 81 } 82 }; 83 84 struct WinResHeaderSuffix { 85 support::ulittle32_t DataVersion; 86 support::ulittle16_t MemoryFlags; 87 support::ulittle16_t Language; 88 support::ulittle32_t Version; 89 support::ulittle32_t Characteristics; 90 }; 91 92 class EmptyResError : public GenericBinaryError { 93 public: EmptyResError(Twine Msg,object_error ECOverride)94 EmptyResError(Twine Msg, object_error ECOverride) 95 : GenericBinaryError(Msg, ECOverride) {} 96 }; 97 98 class ResourceEntryRef { 99 public: 100 Error moveNext(bool &End); checkTypeString()101 bool checkTypeString() const { return IsStringType; } getTypeString()102 ArrayRef<UTF16> getTypeString() const { return Type; } getTypeID()103 uint16_t getTypeID() const { return TypeID; } checkNameString()104 bool checkNameString() const { return IsStringName; } getNameString()105 ArrayRef<UTF16> getNameString() const { return Name; } getNameID()106 uint16_t getNameID() const { return NameID; } getDataVersion()107 uint16_t getDataVersion() const { return Suffix->DataVersion; } getLanguage()108 uint16_t getLanguage() const { return Suffix->Language; } getMemoryFlags()109 uint16_t getMemoryFlags() const { return Suffix->MemoryFlags; } getMajorVersion()110 uint16_t getMajorVersion() const { return Suffix->Version >> 16; } getMinorVersion()111 uint16_t getMinorVersion() const { return Suffix->Version; } getCharacteristics()112 uint32_t getCharacteristics() const { return Suffix->Characteristics; } getData()113 ArrayRef<uint8_t> getData() const { return Data; } 114 115 private: 116 friend class WindowsResource; 117 118 ResourceEntryRef(BinaryStreamRef Ref, const WindowsResource *Owner); 119 Error loadNext(); 120 121 static Expected<ResourceEntryRef> create(BinaryStreamRef Ref, 122 const WindowsResource *Owner); 123 124 BinaryStreamReader Reader; 125 const WindowsResource *Owner; 126 bool IsStringType; 127 ArrayRef<UTF16> Type; 128 uint16_t TypeID; 129 bool IsStringName; 130 ArrayRef<UTF16> Name; 131 uint16_t NameID; 132 const WinResHeaderSuffix *Suffix = nullptr; 133 ArrayRef<uint8_t> Data; 134 }; 135 136 class WindowsResource : public Binary { 137 public: 138 Expected<ResourceEntryRef> getHeadEntry(); 139 classof(const Binary * V)140 static bool classof(const Binary *V) { return V->isWinRes(); } 141 142 static Expected<std::unique_ptr<WindowsResource>> 143 createWindowsResource(MemoryBufferRef Source); 144 145 private: 146 friend class ResourceEntryRef; 147 148 WindowsResource(MemoryBufferRef Source); 149 150 BinaryByteStream BBS; 151 }; 152 153 class WindowsResourceParser { 154 public: 155 class TreeNode; 156 WindowsResourceParser(bool MinGW = false); 157 Error parse(WindowsResource *WR, std::vector<std::string> &Duplicates); 158 Error parse(ResourceSectionRef &RSR, StringRef Filename, 159 std::vector<std::string> &Duplicates); 160 void cleanUpManifests(std::vector<std::string> &Duplicates); 161 void printTree(raw_ostream &OS) const; getTree()162 const TreeNode &getTree() const { return Root; } getData()163 const ArrayRef<std::vector<uint8_t>> getData() const { return Data; } getStringTable()164 const ArrayRef<std::vector<UTF16>> getStringTable() const { 165 return StringTable; 166 } 167 168 class TreeNode { 169 public: 170 template <typename T> 171 using Children = std::map<T, std::unique_ptr<TreeNode>>; 172 173 void print(ScopedPrinter &Writer, StringRef Name) const; 174 uint32_t getTreeSize() const; getStringIndex()175 uint32_t getStringIndex() const { return StringIndex; } getDataIndex()176 uint32_t getDataIndex() const { return DataIndex; } getMajorVersion()177 uint16_t getMajorVersion() const { return MajorVersion; } getMinorVersion()178 uint16_t getMinorVersion() const { return MinorVersion; } getCharacteristics()179 uint32_t getCharacteristics() const { return Characteristics; } checkIsDataNode()180 bool checkIsDataNode() const { return IsDataNode; } getIDChildren()181 const Children<uint32_t> &getIDChildren() const { return IDChildren; } getStringChildren()182 const Children<std::string> &getStringChildren() const { 183 return StringChildren; 184 } 185 186 private: 187 friend class WindowsResourceParser; 188 189 // Index is the StringTable vector index for this node's name. 190 static std::unique_ptr<TreeNode> createStringNode(uint32_t Index); 191 static std::unique_ptr<TreeNode> createIDNode(); 192 // DataIndex is the Data vector index that the data node points at. 193 static std::unique_ptr<TreeNode> createDataNode(uint16_t MajorVersion, 194 uint16_t MinorVersion, 195 uint32_t Characteristics, 196 uint32_t Origin, 197 uint32_t DataIndex); 198 199 explicit TreeNode(uint32_t StringIndex); 200 TreeNode(uint16_t MajorVersion, uint16_t MinorVersion, 201 uint32_t Characteristics, uint32_t Origin, uint32_t DataIndex); 202 203 bool addEntry(const ResourceEntryRef &Entry, uint32_t Origin, 204 std::vector<std::vector<uint8_t>> &Data, 205 std::vector<std::vector<UTF16>> &StringTable, 206 TreeNode *&Result); 207 TreeNode &addTypeNode(const ResourceEntryRef &Entry, 208 std::vector<std::vector<UTF16>> &StringTable); 209 TreeNode &addNameNode(const ResourceEntryRef &Entry, 210 std::vector<std::vector<UTF16>> &StringTable); 211 bool addLanguageNode(const ResourceEntryRef &Entry, uint32_t Origin, 212 std::vector<std::vector<uint8_t>> &Data, 213 TreeNode *&Result); 214 bool addDataChild(uint32_t ID, uint16_t MajorVersion, uint16_t MinorVersion, 215 uint32_t Characteristics, uint32_t Origin, 216 uint32_t DataIndex, TreeNode *&Result); 217 TreeNode &addIDChild(uint32_t ID); 218 TreeNode &addNameChild(ArrayRef<UTF16> NameRef, 219 std::vector<std::vector<UTF16>> &StringTable); 220 void shiftDataIndexDown(uint32_t Index); 221 222 bool IsDataNode = false; 223 uint32_t StringIndex; 224 uint32_t DataIndex; 225 Children<uint32_t> IDChildren; 226 Children<std::string> StringChildren; 227 uint16_t MajorVersion = 0; 228 uint16_t MinorVersion = 0; 229 uint32_t Characteristics = 0; 230 231 // The .res file that defined this TreeNode, for diagnostics. 232 // Index into InputFilenames. 233 uint32_t Origin; 234 }; 235 236 struct StringOrID { 237 bool IsString; 238 ArrayRef<UTF16> String; 239 uint32_t ID; 240 StringOrIDStringOrID241 StringOrID(uint32_t ID) : IsString(false), ID(ID) {} StringOrIDStringOrID242 StringOrID(ArrayRef<UTF16> String) : IsString(true), String(String) {} 243 }; 244 245 private: 246 Error addChildren(TreeNode &Node, ResourceSectionRef &RSR, 247 const coff_resource_dir_table &Table, uint32_t Origin, 248 std::vector<StringOrID> &Context, 249 std::vector<std::string> &Duplicates); 250 bool shouldIgnoreDuplicate(const ResourceEntryRef &Entry) const; 251 bool shouldIgnoreDuplicate(const std::vector<StringOrID> &Context) const; 252 253 TreeNode Root; 254 std::vector<std::vector<uint8_t>> Data; 255 std::vector<std::vector<UTF16>> StringTable; 256 257 std::vector<std::string> InputFilenames; 258 259 bool MinGW; 260 }; 261 262 Expected<std::unique_ptr<MemoryBuffer>> 263 writeWindowsResourceCOFF(llvm::COFF::MachineTypes MachineType, 264 const WindowsResourceParser &Parser, 265 uint32_t TimeDateStamp); 266 267 void printResourceTypeName(uint16_t TypeID, raw_ostream &OS); 268 } // namespace object 269 } // namespace llvm 270 271 #endif 272