[apple/ld64.git] / src / ld / passes / dtrace_dof.cpp

/* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
 *
 * Copyright (c) 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 <stdint.h>
#include <math.h>
#include <unistd.h>
#include <dlfcn.h>

#include <vector>
#include <map>
#include <ext/hash_map>

#include "ld.hpp"
#include "dtrace_dof.h"

// prototype for entry point in libdtrace.dylib
typedef uint8_t* (*createdof_func_t)(cpu_type_t, unsigned int, const char*[], unsigned int, const char*[], const char*[], uint64_t offsetsInDOF[], size_t* size);


namespace ld {
namespace passes {
namespace dtrace {

class File; // forward reference

class Atom : public ld::Atom {
public:
											Atom(class File& f, const char* n,  const uint8_t* content, uint64_t sz);

	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)					{ }
	virtual ld::Fixup::iterator				fixupsBegin() const				{ return &_fixups[0]; }
	virtual ld::Fixup::iterator				fixupsEnd() const				{ return &_fixups[_fixups.size()]; }

protected:
	friend class File;
	virtual									~Atom() {}
	
	class File&								_file;
	const char*								_name;
	const uint8_t*							_content;
	uint64_t								_size;
	mutable std::vector<ld::Fixup>			_fixups;
};


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="dof")
									: ld::File(pth, 0, ord),
									  _atom(*this, symbolName, fileContent, fileLength), 
									  _section(segmentName, sectionName, ld::Section::typeDtraceDOF) { }
	virtual						~File() {}
	
	virtual bool				forEachAtom(AtomHandler& h) const { h.doAtom(_atom); return true; }
	virtual bool				justInTimeforEachAtom(const char* name, AtomHandler&) const { return false; }

	void						reserveFixups(unsigned int count) { _atom._fixups.reserve(count); }
	void						addSectionFixup(const ld::Fixup& f) { _atom._fixups.push_back(f); }
	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, false, false, false, ld::Atom::Alignment(0)), 
		_file(f), _name(strdup(n)), _content(content), _size(sz) {}


class CStringEquals
{
public:
	bool operator()(const char* left, const char* right) const { return (strcmp(left, right) == 0); }
};

struct DTraceProbeInfo {
	DTraceProbeInfo(const ld::Atom* a, uint32_t o, const char* n) : atom(a), offset(o), probeName(n) {}
	const ld::Atom*					atom;
	uint32_t						offset;
	const char*						probeName;
};
typedef __gnu_cxx::hash_map<const char*, std::vector<DTraceProbeInfo>, __gnu_cxx::hash<const char*>, CStringEquals>	ProviderToProbes;
typedef	__gnu_cxx::hash_set<const char*, __gnu_cxx::hash<const char*>, CStringEquals>  CStringSet;


void doPass(const Options& opts, ld::Internal& internal)
{
	static bool log = false;
	
	// only make __dof section in final linked images
	if ( opts.outputKind() == Options::kObjectFile )
		return;

	// scan all atoms looking for dtrace probes
	std::vector<DTraceProbeInfo>					probeSites;
	std::vector<DTraceProbeInfo>					isEnabledSites;
	std::map<const ld::Atom*,CStringSet>			atomToDtraceTypes;
	for (std::vector<ld::Internal::FinalSection*>::iterator sit=internal.sections.begin(); sit != internal.sections.end(); ++sit) {
		ld::Internal::FinalSection* sect = *sit;
		if ( sect->type() != ld::Section::typeCode ) 
			continue;
		for (std::vector<const ld::Atom*>::iterator ait=sect->atoms.begin();  ait != sect->atoms.end(); ++ait) {
			const ld::Atom* atom = *ait;
			for (ld::Fixup::iterator fit = atom->fixupsBegin(), end=atom->fixupsEnd(); fit != end; ++fit) {
				switch ( fit->kind ) {
					case ld::Fixup::kindStoreX86DtraceCallSiteNop:
					case ld::Fixup::kindStoreARMDtraceCallSiteNop:
					case ld::Fixup::kindStoreThumbDtraceCallSiteNop:
						probeSites.push_back(DTraceProbeInfo(atom, fit->offsetInAtom, fit->u.name));
						break;
					case ld::Fixup::kindStoreX86DtraceIsEnableSiteClear:
					case ld::Fixup::kindStoreARMDtraceIsEnableSiteClear:
					case ld::Fixup::kindStoreThumbDtraceIsEnableSiteClear:
						isEnabledSites.push_back(DTraceProbeInfo(atom, fit->offsetInAtom, fit->u.name));
						break;
					case ld::Fixup::kindDtraceExtra:
						atomToDtraceTypes[atom].insert(fit->u.name);
						break;
					default:
						break;
				}
			}
		}
	}

	// if no probes, we're done
	if ( (probeSites.size() == 0) && (isEnabledSites.size() == 0) ) 
		return;
	
	ld::Fixup::Kind storeKind = ld::Fixup::kindNone;
	switch ( opts.architecture() ) {
		case CPU_TYPE_I386:
		case CPU_TYPE_X86_64:
		case CPU_TYPE_ARM:
			storeKind = ld::Fixup::kindStoreLittleEndian32;
			break;
		default:
			throw "unsupported arch for DOF";
	}
	
	// partition probes by provider name
	// The symbol names looks like:
	//	"___dtrace_probe$" provider-name "$" probe-name [ "$"... ]
	//	"___dtrace_isenabled$" provider-name "$" probe-name [ "$"... ]
	ProviderToProbes providerToProbes;
	std::vector<DTraceProbeInfo> emptyList;
	for(std::vector<DTraceProbeInfo>::iterator it = probeSites.begin(); it != probeSites.end(); ++it) {
		// ignore probes in functions that were coalesed away rdar://problem/5628149
		if ( it->atom->coalescedAway() )
			continue;
		const char* providerStart = &it->probeName[16];
		const char* providerEnd = strchr(providerStart, '$');
		if ( providerEnd != NULL ) {
			char providerName[providerEnd-providerStart+1];
			strlcpy(providerName, providerStart, providerEnd-providerStart+1);
			ProviderToProbes::iterator pos = providerToProbes.find(providerName);
			if ( pos == providerToProbes.end() ) {
				const char* dup = strdup(providerName);
				providerToProbes[dup] = emptyList;
			}
			providerToProbes[providerName].push_back(*it);
		}
	}
	for(std::vector<DTraceProbeInfo>::iterator it = isEnabledSites.begin(); it != isEnabledSites.end(); ++it) {
		// ignore probes in functions that were coalesed away rdar://problem/5628149
		if ( it->atom->coalescedAway() )
			continue;
		const char* providerStart = &it->probeName[20];
		const char* providerEnd = strchr(providerStart, '$');
		if ( providerEnd != NULL ) {
			char providerName[providerEnd-providerStart+1];
			strlcpy(providerName, providerStart, providerEnd-providerStart+1);
			ProviderToProbes::iterator pos = providerToProbes.find(providerName);
			if ( pos == providerToProbes.end() ) {
				const char* dup = strdup(providerName);
				providerToProbes[dup] = emptyList;
			}
			providerToProbes[providerName].push_back(*it);
		}
	}
	
	// create a DOF section for each provider
	int dofIndex=1;
	CStringSet sectionNamesUsed;
	for(ProviderToProbes::iterator pit = providerToProbes.begin(); pit != providerToProbes.end(); ++pit, ++dofIndex) {
		const char* providerName = pit->first;
		const std::vector<DTraceProbeInfo>& probes = pit->second;

		// open library and find dtrace_create_dof()
		void* handle = dlopen("/usr/lib/libdtrace.dylib", RTLD_LAZY);
		if ( handle == NULL )
			throwf("couldn't dlopen() /usr/lib/libdtrace.dylib: %s", dlerror());
		createdof_func_t pCreateDOF = (createdof_func_t)dlsym(handle, "dtrace_ld_create_dof");
		if ( pCreateDOF == NULL )
			throwf("couldn't find \"dtrace_ld_create_dof\" in /usr/lib/libdtrace.dylib: %s", dlerror());
		// build list of typedefs/stability infos for this provider
		CStringSet types;
		for(std::vector<DTraceProbeInfo>::const_iterator it = probes.begin(); it != probes.end(); ++it) {
			std::map<const ld::Atom*,CStringSet>::iterator pos = atomToDtraceTypes.find(it->atom);
			if ( pos != atomToDtraceTypes.end() ) {
				for(CStringSet::iterator sit = pos->second.begin(); sit != pos->second.end(); ++sit) {
					const char* providerStart = strchr(*sit, '$')+1;
					const char* providerEnd = strchr(providerStart, '$');
					if ( providerEnd != NULL ) {
						char aProviderName[providerEnd-providerStart+1];
						strlcpy(aProviderName, providerStart, providerEnd-providerStart+1);
						if ( strcmp(aProviderName, providerName) == 0 )
							types.insert(*sit);
					}
				}
			}
		}
		int typeCount = types.size();
		const char* typeNames[typeCount];
		//fprintf(stderr, "types for %s:\n", providerName);
		uint32_t index = 0;
		for(CStringSet::iterator it = types.begin(); it != types.end(); ++it) {
			typeNames[index] = *it;
			//fprintf(stderr, "\t%s\n", *it);
			++index;
		}
		
		// build list of probe/isenabled sites
		const uint32_t probeCount = probes.size();
		const char* probeNames[probeCount];
		const char* funtionNames[probeCount];
		uint64_t offsetsInDOF[probeCount];
		index = 0;
		for(std::vector<DTraceProbeInfo>::const_iterator it = probes.begin(); it != probes.end(); ++it) {
			probeNames[index] = it->probeName;
			funtionNames[index] = it->atom->name();
			offsetsInDOF[index] = 0;
			++index;
		}
		if ( log ) {
			fprintf(stderr, "calling libtrace to create DOF:\n");
			fprintf(stderr, "   types::\n");
			for(int i=0; i < typeCount; ++i) 
				fprintf(stderr, "     [%u]\t %s\n", i, typeNames[i]);
			fprintf(stderr, "   probes::\n");
			for(uint32_t i=0; i < probeCount; ++i) 
				fprintf(stderr, "     [%u]\t %s in %s\n", i, probeNames[i], funtionNames[i]);
		}
		
		// call dtrace library to create DOF section
		size_t dofSectionSize;
		uint8_t* p = (*pCreateDOF)(opts.architecture(), typeCount, typeNames, probeCount, probeNames, funtionNames, offsetsInDOF, &dofSectionSize);
		if ( p != NULL ) {
			char* sectionName = new char[18]; // alloc new string, pass ownership to File()
			strcpy(sectionName, "__dof_");
			strlcpy(&sectionName[6], providerName, 10);
			// create unique section name so each DOF is in its own section
			if ( sectionNamesUsed.count(sectionName) != 0 ) {
				sectionName[15] = '0';
				sectionName[16] = '\0';
				while ( sectionNamesUsed.count(sectionName) != 0 ) {
					++sectionName[15];
				}
			}
			sectionNamesUsed.insert(sectionName);
			char symbolName[strlen(providerName)+64];
			sprintf(symbolName, "__dtrace_dof_for_provider_%s", providerName);
			File* f = new File("__TEXT", sectionName, "dtrace", p, dofSectionSize, 0, symbolName);
			if ( log ) {
				fprintf(stderr, "libdtrace created DOF of size %ld\n", dofSectionSize);
			}
			// add references
			f->reserveFixups(3*probeCount);
			for (uint32_t i=0; i < probeCount; ++i) {
				uint64_t offset = offsetsInDOF[i];
				//fprintf(stderr, "%s offset[%d]=0x%08llX\n", providerName, i, offset);
				if ( offset > dofSectionSize )
					throwf("offsetsInDOF[%d]=%0llX > dofSectionSize=%0lX\n", i, offset, dofSectionSize);
				f->addSectionFixup(ld::Fixup(offset, ld::Fixup::k1of4, ld::Fixup::kindSetTargetAddress, probes[i].atom));
				f->addSectionFixup(ld::Fixup(offset, ld::Fixup::k2of4, ld::Fixup::kindAddAddend, probes[i].offset));
				f->addSectionFixup(ld::Fixup(offset, ld::Fixup::k3of4, ld::Fixup::kindSubtractTargetAddress, &f->atom()));
				f->addSectionFixup(ld::Fixup(offset, ld::Fixup::k4of4, storeKind));
			}
			// insert new section
			internal.addAtom(f->atom());
		}
		else {
			throw "error creating dtrace DOF section";
		}
	}
	

}


} // namespace dtrace
} // namespace passes 
} // namespace ld
Commit	Line	Data
a645023d A	1	/* -- mode: C++; c-basic-offset: 4; tab-width: 4 --
	2	*
	3	* Copyright (c) 2009 Apple Inc. All rights reserved.
	4	*
	5	* @APPLE_LICENSE_HEADER_START@
	6	*
	7	* This file contains Original Code and/or Modifications of Original Code
	8	* as defined in and that are subject to the Apple Public Source License
	9	* Version 2.0 (the 'License'). You may not use this file except in
	10	* compliance with the License. Please obtain a copy of the License at
	11	* http://www.opensource.apple.com/apsl/ and read it before using this
	12	* file.
	13	*
	14	* The Original Code and all software distributed under the License are
	15	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	16	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	17	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	19	* Please see the License for the specific language governing rights and
	20	* limitations under the License.
	21	*
	22	* @APPLE_LICENSE_HEADER_END@
	23	*/
	24
	25
	26	#include <stdint.h>
	27	#include <math.h>
	28	#include <unistd.h>
	29	#include <dlfcn.h>
	30
	31	#include <vector>
	32	#include <map>
	33	#include <ext/hash_map>
	34
	35	#include "ld.hpp"
	36	#include "dtrace_dof.h"
	37
	38	// prototype for entry point in libdtrace.dylib
	39	typedef uint8_t* (createdof_func_t)(cpu_type_t, unsigned int, const char[], unsigned int, const char[], const char[], uint64_t offsetsInDOF[], size_t* size);
	40
	41
	42	namespace ld {
	43	namespace passes {
	44	namespace dtrace {
	45
	46	class File; // forward reference
	47
	48	class Atom : public ld::Atom {
	49	public:
	50	Atom(class File& f, const char* n, const uint8_t* content, uint64_t sz);
	51
	52	virtual ld::File* file() const { return (ld::File*)&_file; }
	53	virtual bool translationUnitSource(const char dir, const char ) const
	54	{ return false; }
	55	virtual const char* name() const { return _name; }
	56	virtual uint64_t size() const { return _size; }
	57	virtual uint64_t objectAddress() const { return 0; }
	58	virtual void copyRawContent(uint8_t buffer[]) const
	59	{ memcpy(buffer, _content, _size); }
	60	virtual void setScope(Scope) { }
	61	virtual ld::Fixup::iterator fixupsBegin() const { return &_fixups[0]; }
	62	virtual ld::Fixup::iterator fixupsEnd() const { return &_fixups[_fixups.size()]; }
	63
	64	protected:
65	friend class File;
66	virtual ~Atom() {}
67
68	class File& _file;
69	const char* _name;
70	const uint8_t* _content;
71	uint64_t _size;
72	mutable std::vector<ld::Fixup> _fixups;
73	};
74
75
76	class File : public ld::File
77	{
78	public:
79	File(const char* segmentName, const char* sectionName, const char* pth,
80	const uint8_t fileContent[], uint64_t fileLength, uint32_t ord,
81	const char* symbolName="dof")
82	: ld::File(pth, 0, ord),
83	_atom(*this, symbolName, fileContent, fileLength),
84	_section(segmentName, sectionName, ld::Section::typeDtraceDOF) { }
85	virtual ~File() {}
86
87	virtual bool forEachAtom(AtomHandler& h) const { h.doAtom(_atom); return true; }
88	virtual bool justInTimeforEachAtom(const char* name, AtomHandler&) const { return false; }
89
90	void reserveFixups(unsigned int count) { _atom._fixups.reserve(count); }
91	void addSectionFixup(const ld::Fixup& f) { _atom._fixups.push_back(f); }
92	ld::Atom& atom() { return _atom; }
93	private:
94	friend class Atom;
95
96	Atom _atom;
97	ld::Section _section;
98	};
99
100	Atom::Atom(File& f, const char* n, const uint8_t* content, uint64_t sz)
101	: ld::Atom(f._section, ld::Atom::definitionRegular, ld::Atom::combineNever,
102	ld::Atom::scopeTranslationUnit, ld::Atom::typeUnclassified,
103	symbolTableNotIn, false, false, false, ld::Atom::Alignment(0)),
104	_file(f), _name(strdup(n)), _content(content), _size(sz) {}
105
106
107
108	class CStringEquals
109	{
110	public:
111	bool operator()(const char* left, const char* right) const { return (strcmp(left, right) == 0); }
112	};
113
114	struct DTraceProbeInfo {
115	DTraceProbeInfo(const ld::Atom* a, uint32_t o, const char* n) : atom(a), offset(o), probeName(n) {}
116	const ld::Atom* atom;
117	uint32_t offset;
118	const char* probeName;
119	};
120	typedef __gnu_cxx::hash_map<const char, std::vector<DTraceProbeInfo>, __gnu_cxx::hash<const char>, CStringEquals> ProviderToProbes;
121	typedef __gnu_cxx::hash_set<const char, __gnu_cxx::hash<const char>, CStringEquals> CStringSet;
122
123
124
125	void doPass(const Options& opts, ld::Internal& internal)
126	{
127	static bool log = false;
128
129	// only make __dof section in final linked images
130	if ( opts.outputKind() == Options::kObjectFile )
131	return;
132
133	// scan all atoms looking for dtrace probes
134	std::vector<DTraceProbeInfo> probeSites;
135	std::vector<DTraceProbeInfo> isEnabledSites;
136	std::map<const ld::Atom*,CStringSet> atomToDtraceTypes;
137	for (std::vector<ld::Internal::FinalSection*>::iterator sit=internal.sections.begin(); sit != internal.sections.end(); ++sit) {
138	ld::Internal::FinalSection* sect = *sit;
139	if ( sect->type() != ld::Section::typeCode )
140	continue;
141	for (std::vector<const ld::Atom*>::iterator ait=sect->atoms.begin(); ait != sect->atoms.end(); ++ait) {
142	const ld::Atom* atom = *ait;
143	for (ld::Fixup::iterator fit = atom->fixupsBegin(), end=atom->fixupsEnd(); fit != end; ++fit) {
144	switch ( fit->kind ) {
145	case ld::Fixup::kindStoreX86DtraceCallSiteNop:
a645023d A	146	case ld::Fixup::kindStoreARMDtraceCallSiteNop:
	147	case ld::Fixup::kindStoreThumbDtraceCallSiteNop:
	148	probeSites.push_back(DTraceProbeInfo(atom, fit->offsetInAtom, fit->u.name));
	149	break;
	150	case ld::Fixup::kindStoreX86DtraceIsEnableSiteClear:
a645023d A	151	case ld::Fixup::kindStoreARMDtraceIsEnableSiteClear:
	152	case ld::Fixup::kindStoreThumbDtraceIsEnableSiteClear:
	153	isEnabledSites.push_back(DTraceProbeInfo(atom, fit->offsetInAtom, fit->u.name));
	154	break;
	155	case ld::Fixup::kindDtraceExtra:
	156	atomToDtraceTypes[atom].insert(fit->u.name);
	157	break;
	158	default:
	159	break;
	160	}
	161	}
	162	}
	163	}
	164
	165	// if no probes, we're done
	166	if ( (probeSites.size() == 0) && (isEnabledSites.size() == 0) )
	167	return;
	168
	169	ld::Fixup::Kind storeKind = ld::Fixup::kindNone;
	170	switch ( opts.architecture() ) {
a645023d A	171	case CPU_TYPE_I386:
	172	case CPU_TYPE_X86_64:
	173	case CPU_TYPE_ARM:
	174	storeKind = ld::Fixup::kindStoreLittleEndian32;
	175	break;
	176	default:
	177	throw "unsupported arch for DOF";
	178	}
	179
	180	// partition probes by provider name
	181	// The symbol names looks like:
	182	// "___dtrace_probe$" provider-name "$" probe-name [ "$"... ]
	183	// "___dtrace_isenabled$" provider-name "$" probe-name [ "$"... ]
	184	ProviderToProbes providerToProbes;
	185	std::vector<DTraceProbeInfo> emptyList;
	186	for(std::vector<DTraceProbeInfo>::iterator it = probeSites.begin(); it != probeSites.end(); ++it) {
	187	// ignore probes in functions that were coalesed away rdar://problem/5628149
	188	if ( it->atom->coalescedAway() )
	189	continue;
	190	const char* providerStart = &it->probeName[16];
	191	const char* providerEnd = strchr(providerStart, '$');
	192	if ( providerEnd != NULL ) {
	193	char providerName[providerEnd-providerStart+1];
	194	strlcpy(providerName, providerStart, providerEnd-providerStart+1);
	195	ProviderToProbes::iterator pos = providerToProbes.find(providerName);
	196	if ( pos == providerToProbes.end() ) {
	197	const char* dup = strdup(providerName);
	198	providerToProbes[dup] = emptyList;
	199	}
	200	providerToProbes[providerName].push_back(*it);
	201	}
	202	}
	203	for(std::vector<DTraceProbeInfo>::iterator it = isEnabledSites.begin(); it != isEnabledSites.end(); ++it) {
	204	// ignore probes in functions that were coalesed away rdar://problem/5628149
	205	if ( it->atom->coalescedAway() )
	206	continue;
	207	const char* providerStart = &it->probeName[20];
	208	const char* providerEnd = strchr(providerStart, '$');
	209	if ( providerEnd != NULL ) {
	210	char providerName[providerEnd-providerStart+1];
	211	strlcpy(providerName, providerStart, providerEnd-providerStart+1);
	212	ProviderToProbes::iterator pos = providerToProbes.find(providerName);
	213	if ( pos == providerToProbes.end() ) {
	214	const char* dup = strdup(providerName);
	215	providerToProbes[dup] = emptyList;
	216	}
	217	providerToProbes[providerName].push_back(*it);
	218	}
	219	}
	220
	221	// create a DOF section for each provider
	222	int dofIndex=1;
	223	CStringSet sectionNamesUsed;
	224	for(ProviderToProbes::iterator pit = providerToProbes.begin(); pit != providerToProbes.end(); ++pit, ++dofIndex) {
	225	const char* providerName = pit->first;
	226	const std::vector<DTraceProbeInfo>& probes = pit->second;
	227
	228	// open library and find dtrace_create_dof()
	229	void* handle = dlopen("/usr/lib/libdtrace.dylib", RTLD_LAZY);
	230	if ( handle == NULL )
	231	throwf("couldn't dlopen() /usr/lib/libdtrace.dylib: %s", dlerror());
	232	createdof_func_t pCreateDOF = (createdof_func_t)dlsym(handle, "dtrace_ld_create_dof");
	233	if ( pCreateDOF == NULL )
	234	throwf("couldn't find \"dtrace_ld_create_dof\" in /usr/lib/libdtrace.dylib: %s", dlerror());
235	// build list of typedefs/stability infos for this provider
236	CStringSet types;
237	for(std::vector<DTraceProbeInfo>::const_iterator it = probes.begin(); it != probes.end(); ++it) {
238	std::map<const ld::Atom*,CStringSet>::iterator pos = atomToDtraceTypes.find(it->atom);
239	if ( pos != atomToDtraceTypes.end() ) {
240	for(CStringSet::iterator sit = pos->second.begin(); sit != pos->second.end(); ++sit) {
241	const char* providerStart = strchr(*sit, '$')+1;
242	const char* providerEnd = strchr(providerStart, '$');
243	if ( providerEnd != NULL ) {
244	char aProviderName[providerEnd-providerStart+1];
245	strlcpy(aProviderName, providerStart, providerEnd-providerStart+1);
246	if ( strcmp(aProviderName, providerName) == 0 )
247	types.insert(*sit);
248	}
249	}
250	}
251	}
252	int typeCount = types.size();
253	const char* typeNames[typeCount];
254	//fprintf(stderr, "types for %s:\n", providerName);
255	uint32_t index = 0;
256	for(CStringSet::iterator it = types.begin(); it != types.end(); ++it) {
257	typeNames[index] = *it;
258	//fprintf(stderr, "\t%s\n", *it);
259	++index;
260	}
261
262	// build list of probe/isenabled sites
263	const uint32_t probeCount = probes.size();
264	const char* probeNames[probeCount];
265	const char* funtionNames[probeCount];
266	uint64_t offsetsInDOF[probeCount];
267	index = 0;
268	for(std::vector<DTraceProbeInfo>::const_iterator it = probes.begin(); it != probes.end(); ++it) {
269	probeNames[index] = it->probeName;
270	funtionNames[index] = it->atom->name();
271	offsetsInDOF[index] = 0;
272	++index;
273	}
274	if ( log ) {
275	fprintf(stderr, "calling libtrace to create DOF:\n");
276	fprintf(stderr, " types::\n");
277	for(int i=0; i < typeCount; ++i)
278	fprintf(stderr, " [%u]\t %s\n", i, typeNames[i]);
279	fprintf(stderr, " probes::\n");
280	for(uint32_t i=0; i < probeCount; ++i)
281	fprintf(stderr, " [%u]\t %s in %s\n", i, probeNames[i], funtionNames[i]);
282	}
283
284	// call dtrace library to create DOF section
285	size_t dofSectionSize;
286	uint8_t* p = (*pCreateDOF)(opts.architecture(), typeCount, typeNames, probeCount, probeNames, funtionNames, offsetsInDOF, &dofSectionSize);
287	if ( p != NULL ) {
288	char* sectionName = new char[18]; // alloc new string, pass ownership to File()
289	strcpy(sectionName, "__dof_");
290	strlcpy(&sectionName[6], providerName, 10);
291	// create unique section name so each DOF is in its own section
292	if ( sectionNamesUsed.count(sectionName) != 0 ) {
293	sectionName[15] = '0';
294	sectionName[16] = '\0';
295	while ( sectionNamesUsed.count(sectionName) != 0 ) {
296	++sectionName[15];
297	}
298	}
299	sectionNamesUsed.insert(sectionName);
300	char symbolName[strlen(providerName)+64];
301	sprintf(symbolName, "__dtrace_dof_for_provider_%s", providerName);
302	File* f = new File("__TEXT", sectionName, "dtrace", p, dofSectionSize, 0, symbolName);
303	if ( log ) {
304	fprintf(stderr, "libdtrace created DOF of size %ld\n", dofSectionSize);
305	}
306	// add references
307	f->reserveFixups(3*probeCount);
308	for (uint32_t i=0; i < probeCount; ++i) {
309	uint64_t offset = offsetsInDOF[i];
310	//fprintf(stderr, "%s offset[%d]=0x%08llX\n", providerName, i, offset);
311	if ( offset > dofSectionSize )
312	throwf("offsetsInDOF[%d]=%0llX > dofSectionSize=%0lX\n", i, offset, dofSectionSize);
313	f->addSectionFixup(ld::Fixup(offset, ld::Fixup::k1of4, ld::Fixup::kindSetTargetAddress, probes[i].atom));
314	f->addSectionFixup(ld::Fixup(offset, ld::Fixup::k2of4, ld::Fixup::kindAddAddend, probes[i].offset));
315	f->addSectionFixup(ld::Fixup(offset, ld::Fixup::k3of4, ld::Fixup::kindSubtractTargetAddress, &f->atom()));
316	f->addSectionFixup(ld::Fixup(offset, ld::Fixup::k4of4, storeKind));
317	}
318	// insert new section
319	internal.addAtom(f->atom());
320	}
321	else {
322	throw "error creating dtrace DOF section";
323	}
324	}
325
326
327
328	}
329
330
331	} // namespace dtrace
332	} // namespace passes
333	} // namespace ld