ld64-123.2.tar.gz

[apple/ld64.git] / src / ld / parsers / opaque_section_file.cpp

diff --git a/src/ld/parsers/opaque_section_file.cpp b/src/ld/parsers/opaque_section_file.cpp
new file mode 100644 (file)
index 0000000..660f66d
--- /dev/null
+++ b/src/ld/parsers/opaque_section_file.cpp
@@ -0,0 +1,106 @@
+/* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*- 
+ *
+ * Copyright (c) 2005-2009 Apple Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ * 
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ * 
+ * @APPLE_LICENSE_HEADER_END@
+ */
+
+
+#include <vector>
+
+#include "ld.hpp"
+#include "opaque_section_file.h"
+
+
+namespace opaque_section {
+
+
+
+class Atom : public ld::Atom {
+public:
+       virtual ld::File*                                               file() const                                    { return (ld::File*)&_file; }
+       virtual bool                                                    translationUnitSource(const char** dir, const char** ) const 
+                                                                                                                                                       { return false; }
+       virtual const char*                                             name() const                                    { return _name; }
+       virtual uint64_t                                                size() const                                    { return _size; }
+       virtual uint64_t                                                objectAddress() const                   { return 0; }
+       virtual void                                                    copyRawContent(uint8_t buffer[]) const
+                                                                                                                                                       { memcpy(buffer, _content, _size); }
+       virtual void                                                    setScope(Scope)                                 { }
+
+protected:
+       friend class File;
+                                                                                       Atom(class File& f, const char* n,  const uint8_t* content, uint64_t sz);
+       virtual                                                                 ~Atom() {}
+       
+       class File&                                                             _file;
+       const char*                                                             _name;
+       const uint8_t*                                                  _content;
+       uint64_t                                                                _size;
+};
+
+
+class File : public ld::File 
+{
+public:
+                                                               File(const char* segmentName, const char* sectionName, const char* pth, 
+                                                                       const uint8_t fileContent[], uint64_t fileLength, uint32_t ord, 
+                                                                       const char* symbolName="sect_create")
+                                                                       : ld::File(pth, 0, ord),
+                                                                         _atom(*this, symbolName, fileContent, fileLength), 
+                                                                         _section(segmentName, sectionName, ld::Section::typeUnclassified) { }
+       virtual                                         ~File() { }
+       
+       virtual bool                            forEachAtom(ld::File::AtomHandler& h) const { h.doAtom(_atom); return true; }
+       virtual bool                            justInTimeforEachAtom(const char* name, ld::File::AtomHandler&) const { return false; }
+
+       ld::Atom*                                       atom() { return &_atom; }
+private:
+       friend class Atom;
+       
+       Atom                                            _atom;
+       ld::Section                                     _section;
+};
+
+Atom::Atom(File& f, const char* n,  const uint8_t* content, uint64_t sz)
+       : ld::Atom(f._section, ld::Atom::definitionRegular, ld::Atom::combineNever,
+               ld::Atom::scopeTranslationUnit, ld::Atom::typeUnclassified, 
+               symbolTableNotIn, true, false, false, ld::Atom::Alignment(0)), 
+               _file(f), _name(n), _content(content), _size(sz) {}
+
+
+//
+// main function used by linker for -sectcreate
+//
+ld::File* parse(const char* segmentName, const char* sectionName, const char* path, 
+                                                                       const uint8_t fileContent[], uint64_t fileLength, uint32_t ordinal, 
+                                                                       const char* symbolName)
+{
+       return new File(segmentName, sectionName, path, fileContent, fileLength, ordinal, symbolName);
+}
+
+
+} // namespace opaque_section
+
+
+
+
+
+