fix pointer style to match the style guide
We do this in a lot of places, but we're inconsistent.
Normalize the code to the Google C++ style guide.
Change-Id: Ic2aceab661ce8f6b993dda21b1cdf5d2198dcbbf
Reviewed-on: https://chromium-review.googlesource.com/c/breakpad/breakpad/+/2262932
Reviewed-by: Sterling Augustine <saugustine@google.com>
Reviewed-by: Mark Mentovai <mark@chromium.org>
diff --git a/src/client/ios/Breakpad.h b/src/client/ios/Breakpad.h
index fa790f7..6c9b8bd 100644
--- a/src/client/ios/Breakpad.h
+++ b/src/client/ios/Breakpad.h
@@ -37,7 +37,7 @@
//
// These files can then be uploaded to a server.
-typedef void *BreakpadRef;
+typedef void* BreakpadRef;
#ifdef __cplusplus
extern "C" {
@@ -60,15 +60,15 @@
typedef bool (*BreakpadFilterCallback)(int exception_type,
int exception_code,
mach_port_t crashing_thread,
- void *context);
+ void* context);
// Optional user-defined function that will be called after a network upload
// of a crash report.
// |report_id| will be the id returned by the server, or "ERR" if an error
// occurred.
// |error| will contain the error, or nil if no error occured.
-typedef void (*BreakpadUploadCompletionCallback)(NSString *report_id,
- NSError *error);
+typedef void (*BreakpadUploadCompletionCallback)(NSString* report_id,
+ NSError* error);
// Create a new BreakpadRef object and install it as an exception
// handler. The |parameters| will typically be the contents of your
@@ -163,7 +163,7 @@
// internal values.
// Returns a new BreakpadRef object on success, NULL otherwise.
-BreakpadRef BreakpadCreate(NSDictionary *parameters);
+BreakpadRef BreakpadCreate(NSDictionary* parameters);
// Uninstall and release the data associated with |ref|.
void BreakpadRelease(BreakpadRef ref);
@@ -187,20 +187,20 @@
// TODO (nealsid): separate server parameter dictionary from the
// dictionary used to configure Breakpad, and document limits for each
// independently.
-void BreakpadSetKeyValue(BreakpadRef ref, NSString *key, NSString *value);
-NSString *BreakpadKeyValue(BreakpadRef ref, NSString *key);
-void BreakpadRemoveKeyValue(BreakpadRef ref, NSString *key);
+void BreakpadSetKeyValue(BreakpadRef ref, NSString* key, NSString* value);
+NSString* BreakpadKeyValue(BreakpadRef ref, NSString* key);
+void BreakpadRemoveKeyValue(BreakpadRef ref, NSString* key);
// You can use this method to specify parameters that will be uploaded
// to the crash server. They will be automatically encoded as
// necessary. Note that as mentioned above there are limits on both
// the number of keys and their length.
-void BreakpadAddUploadParameter(BreakpadRef ref, NSString *key,
- NSString *value);
+void BreakpadAddUploadParameter(BreakpadRef ref, NSString* key,
+ NSString* value);
// This method will remove a previously-added parameter from the
// upload parameter set.
-void BreakpadRemoveUploadParameter(BreakpadRef ref, NSString *key);
+void BreakpadRemoveUploadParameter(BreakpadRef ref, NSString* key);
// Method to handle uploading data to the server
@@ -208,10 +208,10 @@
int BreakpadGetCrashReportCount(BreakpadRef ref);
// Returns the next upload configuration. The report file is deleted.
-NSDictionary *BreakpadGetNextReportConfiguration(BreakpadRef ref);
+NSDictionary* BreakpadGetNextReportConfiguration(BreakpadRef ref);
// Returns the date of the most recent crash report.
-NSDate *BreakpadGetDateOfMostRecentCrashReport(BreakpadRef ref);
+NSDate* BreakpadGetDateOfMostRecentCrashReport(BreakpadRef ref);
// Upload next report to the server.
void BreakpadUploadNextReport(BreakpadRef ref);
@@ -220,7 +220,7 @@
// |server_parameters| is additional server parameters to send.
void BreakpadUploadNextReportWithParameters(
BreakpadRef ref,
- NSDictionary *server_parameters,
+ NSDictionary* server_parameters,
BreakpadUploadCompletionCallback callback);
// Upload a report to the server.
@@ -228,8 +228,8 @@
// |configuration| is the configuration of the breakpad report to send.
void BreakpadUploadReportWithParametersAndConfiguration(
BreakpadRef ref,
- NSDictionary *server_parameters,
- NSDictionary *configuration,
+ NSDictionary* server_parameters,
+ NSDictionary* configuration,
BreakpadUploadCompletionCallback callback);
// Handles the network response of a breakpad upload. This function is needed if
@@ -239,21 +239,21 @@
// BreakpadUploadReportWithParametersAndConfiguration.
// |data| and |error| contain the network response.
void BreakpadHandleNetworkResponse(BreakpadRef ref,
- NSDictionary *configuration,
- NSData *data,
- NSError *error);
+ NSDictionary* configuration,
+ NSData* data,
+ NSError* error);
// Upload a file to the server. |data| is the content of the file to sent.
// |server_parameters| is additional server parameters to send.
-void BreakpadUploadData(BreakpadRef ref, NSData *data, NSString *name,
- NSDictionary *server_parameters);
+void BreakpadUploadData(BreakpadRef ref, NSData* data, NSString* name,
+ NSDictionary* server_parameters);
// Generate a breakpad minidump and configuration file in the dump directory.
// The report will be available for uploading. The paths of the created files
// are returned in the dictionary. |server_parameters| is additional server
// parameters to add in the config file.
-NSDictionary *BreakpadGenerateReport(BreakpadRef ref,
- NSDictionary *server_parameters);
+NSDictionary* BreakpadGenerateReport(BreakpadRef ref,
+ NSDictionary* server_parameters);
#ifdef __cplusplus
}
diff --git a/src/client/ios/Breakpad.mm b/src/client/ios/Breakpad.mm
index 2b61bbe..11c5174 100644
--- a/src/client/ios/Breakpad.mm
+++ b/src/client/ios/Breakpad.mm
@@ -84,9 +84,9 @@
// allocation of C++ objects. Note that we don't use operator delete()
// but instead call the objects destructor directly: object->~ClassName();
//
-ProtectedMemoryAllocator *gMasterAllocator = NULL;
-ProtectedMemoryAllocator *gKeyValueAllocator = NULL;
-ProtectedMemoryAllocator *gBreakpadAllocator = NULL;
+ProtectedMemoryAllocator* gMasterAllocator = NULL;
+ProtectedMemoryAllocator* gKeyValueAllocator = NULL;
+ProtectedMemoryAllocator* gBreakpadAllocator = NULL;
// Mutex for thread-safe access to the key/value dictionary used by breakpad.
// It's a global instead of an instance variable of Breakpad
@@ -101,8 +101,8 @@
// Its destructor will first re-protect the memory then release the lock.
class ProtectedMemoryLocker {
public:
- ProtectedMemoryLocker(pthread_mutex_t *mutex,
- ProtectedMemoryAllocator *allocator)
+ ProtectedMemoryLocker(pthread_mutex_t* mutex,
+ ProtectedMemoryAllocator* allocator)
: mutex_(mutex),
allocator_(allocator) {
// Lock the mutex
@@ -127,17 +127,17 @@
ProtectedMemoryLocker(const ProtectedMemoryLocker&);
ProtectedMemoryLocker& operator=(const ProtectedMemoryLocker&);
- pthread_mutex_t *mutex_;
- ProtectedMemoryAllocator *allocator_;
+ pthread_mutex_t* mutex_;
+ ProtectedMemoryAllocator* allocator_;
};
//=============================================================================
class Breakpad {
public:
// factory method
- static Breakpad *Create(NSDictionary *parameters) {
+ static Breakpad* Create(NSDictionary* parameters) {
// Allocate from our special allocation pool
- Breakpad *breakpad =
+ Breakpad* breakpad =
new (gBreakpadAllocator->Allocate(sizeof(Breakpad)))
Breakpad();
@@ -155,62 +155,62 @@
~Breakpad();
- void SetKeyValue(NSString *key, NSString *value);
- NSString *KeyValue(NSString *key);
- void RemoveKeyValue(NSString *key);
- NSArray *CrashReportsToUpload();
- NSString *NextCrashReportToUpload();
- NSDictionary *NextCrashReportConfiguration();
- NSDictionary *FixedUpCrashReportConfiguration(NSDictionary *configuration);
- NSDate *DateOfMostRecentCrashReport();
- void UploadNextReport(NSDictionary *server_parameters);
- void UploadReportWithConfiguration(NSDictionary *configuration,
- NSDictionary *server_parameters,
+ void SetKeyValue(NSString* key, NSString* value);
+ NSString* KeyValue(NSString* key);
+ void RemoveKeyValue(NSString* key);
+ NSArray* CrashReportsToUpload();
+ NSString* NextCrashReportToUpload();
+ NSDictionary* NextCrashReportConfiguration();
+ NSDictionary* FixedUpCrashReportConfiguration(NSDictionary* configuration);
+ NSDate* DateOfMostRecentCrashReport();
+ void UploadNextReport(NSDictionary* server_parameters);
+ void UploadReportWithConfiguration(NSDictionary* configuration,
+ NSDictionary* server_parameters,
BreakpadUploadCompletionCallback callback);
- void UploadData(NSData *data, NSString *name,
- NSDictionary *server_parameters);
- void HandleNetworkResponse(NSDictionary *configuration,
- NSData *data,
- NSError *error);
- NSDictionary *GenerateReport(NSDictionary *server_parameters);
+ void UploadData(NSData* data, NSString* name,
+ NSDictionary* server_parameters);
+ void HandleNetworkResponse(NSDictionary* configuration,
+ NSData* data,
+ NSError* error);
+ NSDictionary* GenerateReport(NSDictionary* server_parameters);
private:
Breakpad()
: handler_(NULL),
config_params_(NULL) {}
- bool Initialize(NSDictionary *parameters);
+ bool Initialize(NSDictionary* parameters);
- bool ExtractParameters(NSDictionary *parameters);
+ bool ExtractParameters(NSDictionary* parameters);
// Dispatches to HandleMinidump()
- static bool HandleMinidumpCallback(const char *dump_dir,
- const char *minidump_id,
- void *context, bool succeeded);
+ static bool HandleMinidumpCallback(const char* dump_dir,
+ const char* minidump_id,
+ void* context, bool succeeded);
- bool HandleMinidump(const char *dump_dir,
- const char *minidump_id);
+ bool HandleMinidump(const char* dump_dir,
+ const char* minidump_id);
// NSException handler
- static void UncaughtExceptionHandler(NSException *exception);
+ static void UncaughtExceptionHandler(NSException* exception);
// Handle an uncaught NSException.
- void HandleUncaughtException(NSException *exception);
+ void HandleUncaughtException(NSException* exception);
// Since ExceptionHandler (w/o namespace) is defined as typedef in OSX's
// MachineExceptions.h, we have to explicitly name the handler.
- google_breakpad::ExceptionHandler *handler_; // The actual handler (STRONG)
+ google_breakpad::ExceptionHandler* handler_; // The actual handler (STRONG)
- LongStringDictionary *config_params_; // Create parameters (STRONG)
+ LongStringDictionary* config_params_; // Create parameters (STRONG)
ConfigFile config_file_;
// A static reference to the current Breakpad instance. Used for handling
// NSException.
- static Breakpad *current_breakpad_;
+ static Breakpad* current_breakpad_;
};
-Breakpad *Breakpad::current_breakpad_ = NULL;
+Breakpad* Breakpad::current_breakpad_ = NULL;
#pragma mark -
#pragma mark Helper functions
@@ -221,14 +221,14 @@
//=============================================================================
static BOOL IsDebuggerActive() {
BOOL result = NO;
- NSUserDefaults *stdDefaults = [NSUserDefaults standardUserDefaults];
+ NSUserDefaults* stdDefaults = [NSUserDefaults standardUserDefaults];
// We check both defaults and the environment variable here
BOOL ignoreDebugger = [stdDefaults boolForKey:@IGNORE_DEBUGGER];
if (!ignoreDebugger) {
- char *ignoreDebuggerStr = getenv(IGNORE_DEBUGGER);
+ char* ignoreDebuggerStr = getenv(IGNORE_DEBUGGER);
ignoreDebugger =
(ignoreDebuggerStr ? strtol(ignoreDebuggerStr, NULL, 10) : 0) != 0;
}
@@ -240,7 +240,7 @@
size_t actualSize;
if (sysctl(mib, mibSize, NULL, &actualSize, NULL, 0) == 0) {
- struct kinfo_proc *info = (struct kinfo_proc *)malloc(actualSize);
+ struct kinfo_proc* info = (struct kinfo_proc*)malloc(actualSize);
if (info) {
// This comes from looking at the Darwin xnu Kernel
@@ -256,10 +256,10 @@
}
//=============================================================================
-bool Breakpad::HandleMinidumpCallback(const char *dump_dir,
- const char *minidump_id,
- void *context, bool succeeded) {
- Breakpad *breakpad = (Breakpad *)context;
+bool Breakpad::HandleMinidumpCallback(const char* dump_dir,
+ const char* minidump_id,
+ void* context, bool succeeded) {
+ Breakpad* breakpad = (Breakpad*)context;
// If our context is damaged or something, just return false to indicate that
// the handler should continue without us.
@@ -270,7 +270,7 @@
}
//=============================================================================
-void Breakpad::UncaughtExceptionHandler(NSException *exception) {
+void Breakpad::UncaughtExceptionHandler(NSException* exception) {
NSSetUncaughtExceptionHandler(NULL);
if (current_breakpad_) {
current_breakpad_->HandleUncaughtException(exception);
@@ -282,7 +282,7 @@
#pragma mark -
//=============================================================================
-bool Breakpad::Initialize(NSDictionary *parameters) {
+bool Breakpad::Initialize(NSDictionary* parameters) {
// Initialize
current_breakpad_ = this;
config_params_ = NULL;
@@ -325,21 +325,21 @@
}
//=============================================================================
-bool Breakpad::ExtractParameters(NSDictionary *parameters) {
- NSString *serverType = [parameters objectForKey:@BREAKPAD_SERVER_TYPE];
- NSString *display = [parameters objectForKey:@BREAKPAD_PRODUCT_DISPLAY];
- NSString *product = [parameters objectForKey:@BREAKPAD_PRODUCT];
- NSString *version = [parameters objectForKey:@BREAKPAD_VERSION];
- NSString *urlStr = [parameters objectForKey:@BREAKPAD_URL];
- NSString *vendor =
+bool Breakpad::ExtractParameters(NSDictionary* parameters) {
+ NSString* serverType = [parameters objectForKey:@BREAKPAD_SERVER_TYPE];
+ NSString* display = [parameters objectForKey:@BREAKPAD_PRODUCT_DISPLAY];
+ NSString* product = [parameters objectForKey:@BREAKPAD_PRODUCT];
+ NSString* version = [parameters objectForKey:@BREAKPAD_VERSION];
+ NSString* urlStr = [parameters objectForKey:@BREAKPAD_URL];
+ NSString* vendor =
[parameters objectForKey:@BREAKPAD_VENDOR];
// We check both parameters and the environment variable here.
- char *envVarDumpSubdirectory = getenv(BREAKPAD_DUMP_DIRECTORY);
- NSString *dumpSubdirectory = envVarDumpSubdirectory ?
+ char* envVarDumpSubdirectory = getenv(BREAKPAD_DUMP_DIRECTORY);
+ NSString* dumpSubdirectory = envVarDumpSubdirectory ?
[NSString stringWithUTF8String:envVarDumpSubdirectory] :
[parameters objectForKey:@BREAKPAD_DUMP_DIRECTORY];
- NSDictionary *serverParameters =
+ NSDictionary* serverParameters =
[parameters objectForKey:@BREAKPAD_SERVER_PARAMETER_DICT];
if (!product)
@@ -360,7 +360,7 @@
}
if (!dumpSubdirectory) {
- NSString *cachePath =
+ NSString* cachePath =
[NSSearchPathForDirectoriesInDomains(NSCachesDirectory,
NSUserDomainMask,
YES)
@@ -388,7 +388,7 @@
new (gKeyValueAllocator->Allocate(sizeof(LongStringDictionary)))
LongStringDictionary();
- LongStringDictionary &dictionary = *config_params_;
+ LongStringDictionary& dictionary = *config_params_;
dictionary.SetKeyValue(BREAKPAD_SERVER_TYPE, [serverType UTF8String]);
dictionary.SetKeyValue(BREAKPAD_PRODUCT_DISPLAY, [display UTF8String]);
@@ -407,8 +407,8 @@
if (serverParameters) {
// For each key-value pair, call BreakpadAddUploadParameter()
- NSEnumerator *keyEnumerator = [serverParameters keyEnumerator];
- NSString *aParameter;
+ NSEnumerator* keyEnumerator = [serverParameters keyEnumerator];
+ NSString* aParameter;
while ((aParameter = [keyEnumerator nextObject])) {
BreakpadAddUploadParameter(this, aParameter,
[serverParameters objectForKey:aParameter]);
@@ -418,7 +418,7 @@
}
//=============================================================================
-void Breakpad::SetKeyValue(NSString *key, NSString *value) {
+void Breakpad::SetKeyValue(NSString* key, NSString* value) {
// We allow nil values. This is the same as removing the keyvalue.
if (!config_params_ || !key)
return;
@@ -427,7 +427,7 @@
}
//=============================================================================
-NSString *Breakpad::KeyValue(NSString *key) {
+NSString* Breakpad::KeyValue(NSString* key) {
if (!config_params_ || !key)
return nil;
@@ -436,44 +436,44 @@
}
//=============================================================================
-void Breakpad::RemoveKeyValue(NSString *key) {
+void Breakpad::RemoveKeyValue(NSString* key) {
if (!config_params_ || !key) return;
config_params_->RemoveKey([key UTF8String]);
}
//=============================================================================
-NSArray *Breakpad::CrashReportsToUpload() {
- NSString *directory = KeyValue(@BREAKPAD_DUMP_DIRECTORY);
+NSArray* Breakpad::CrashReportsToUpload() {
+ NSString* directory = KeyValue(@BREAKPAD_DUMP_DIRECTORY);
if (!directory)
return nil;
- NSArray *dirContents = [[NSFileManager defaultManager]
+ NSArray* dirContents = [[NSFileManager defaultManager]
contentsOfDirectoryAtPath:directory error:nil];
- NSArray *configs = [dirContents filteredArrayUsingPredicate:[NSPredicate
+ NSArray* configs = [dirContents filteredArrayUsingPredicate:[NSPredicate
predicateWithFormat:@"self BEGINSWITH 'Config-'"]];
return configs;
}
//=============================================================================
-NSString *Breakpad::NextCrashReportToUpload() {
- NSString *directory = KeyValue(@BREAKPAD_DUMP_DIRECTORY);
+NSString* Breakpad::NextCrashReportToUpload() {
+ NSString* directory = KeyValue(@BREAKPAD_DUMP_DIRECTORY);
if (!directory)
return nil;
- NSString *config = [CrashReportsToUpload() lastObject];
+ NSString* config = [CrashReportsToUpload() lastObject];
if (!config)
return nil;
return [NSString stringWithFormat:@"%@/%@", directory, config];
}
//=============================================================================
-NSDictionary *Breakpad::NextCrashReportConfiguration() {
- NSDictionary *configuration = [Uploader readConfigurationDataFromFile:NextCrashReportToUpload()];
+NSDictionary* Breakpad::NextCrashReportConfiguration() {
+ NSDictionary* configuration = [Uploader readConfigurationDataFromFile:NextCrashReportToUpload()];
return FixedUpCrashReportConfiguration(configuration);
}
//=============================================================================
-NSDictionary *Breakpad::FixedUpCrashReportConfiguration(NSDictionary *configuration) {
- NSMutableDictionary *fixedConfiguration = [[configuration mutableCopy] autorelease];
+NSDictionary* Breakpad::FixedUpCrashReportConfiguration(NSDictionary* configuration) {
+ NSMutableDictionary* fixedConfiguration = [[configuration mutableCopy] autorelease];
// kReporterMinidumpDirectoryKey can become stale because the app's data container path includes
// an UUID that is not guaranteed to stay the same over time.
[fixedConfiguration setObject:KeyValue(@BREAKPAD_DUMP_DIRECTORY)
@@ -482,19 +482,19 @@
}
//=============================================================================
-NSDate *Breakpad::DateOfMostRecentCrashReport() {
- NSString *directory = KeyValue(@BREAKPAD_DUMP_DIRECTORY);
+NSDate* Breakpad::DateOfMostRecentCrashReport() {
+ NSString* directory = KeyValue(@BREAKPAD_DUMP_DIRECTORY);
if (!directory) {
return nil;
}
- NSFileManager *fileManager = [NSFileManager defaultManager];
- NSArray *dirContents = [fileManager contentsOfDirectoryAtPath:directory error:nil];
- NSArray *dumps = [dirContents filteredArrayUsingPredicate:[NSPredicate
+ NSFileManager* fileManager = [NSFileManager defaultManager];
+ NSArray* dirContents = [fileManager contentsOfDirectoryAtPath:directory error:nil];
+ NSArray* dumps = [dirContents filteredArrayUsingPredicate:[NSPredicate
predicateWithFormat:@"self ENDSWITH '.dmp'"]];
- NSDate *mostRecentCrashReportDate = nil;
- for (NSString *dump in dumps) {
- NSString *filePath = [directory stringByAppendingPathComponent:dump];
- NSDate *crashReportDate =
+ NSDate* mostRecentCrashReportDate = nil;
+ for (NSString* dump in dumps) {
+ NSString* filePath = [directory stringByAppendingPathComponent:dump];
+ NSDate* crashReportDate =
[[fileManager attributesOfItemAtPath:filePath error:nil] fileCreationDate];
if (!mostRecentCrashReportDate) {
mostRecentCrashReportDate = crashReportDate;
@@ -506,29 +506,29 @@
}
//=============================================================================
-void Breakpad::HandleNetworkResponse(NSDictionary *configuration,
- NSData *data,
- NSError *error) {
- Uploader *uploader = [[[Uploader alloc]
+void Breakpad::HandleNetworkResponse(NSDictionary* configuration,
+ NSData* data,
+ NSError* error) {
+ Uploader* uploader = [[[Uploader alloc]
initWithConfig:configuration] autorelease];
[uploader handleNetworkResponse:data withError:error];
}
//=============================================================================
void Breakpad::UploadReportWithConfiguration(
- NSDictionary *configuration,
- NSDictionary *server_parameters,
+ NSDictionary* configuration,
+ NSDictionary* server_parameters,
BreakpadUploadCompletionCallback callback) {
- Uploader *uploader = [[[Uploader alloc]
+ Uploader* uploader = [[[Uploader alloc]
initWithConfig:configuration] autorelease];
if (!uploader)
return;
- for (NSString *key in server_parameters) {
+ for (NSString* key in server_parameters) {
[uploader addServerParameter:[server_parameters objectForKey:key]
forKey:key];
}
if (callback) {
- [uploader setUploadCompletionBlock:^(NSString *report_id, NSError *error) {
+ [uploader setUploadCompletionBlock:^(NSString* report_id, NSError* error) {
dispatch_async(dispatch_get_main_queue(), ^{
callback(report_id, error);
});
@@ -538,8 +538,8 @@
}
//=============================================================================
-void Breakpad::UploadNextReport(NSDictionary *server_parameters) {
- NSDictionary *configuration = NextCrashReportConfiguration();
+void Breakpad::UploadNextReport(NSDictionary* server_parameters) {
+ NSDictionary* configuration = NextCrashReportConfiguration();
if (configuration) {
return UploadReportWithConfiguration(configuration, server_parameters,
nullptr);
@@ -547,19 +547,19 @@
}
//=============================================================================
-void Breakpad::UploadData(NSData *data, NSString *name,
- NSDictionary *server_parameters) {
- NSMutableDictionary *config = [NSMutableDictionary dictionary];
+void Breakpad::UploadData(NSData* data, NSString* name,
+ NSDictionary* server_parameters) {
+ NSMutableDictionary* config = [NSMutableDictionary dictionary];
LongStringDictionary::Iterator it(*config_params_);
- while (const LongStringDictionary::Entry *next = it.Next()) {
+ while (const LongStringDictionary::Entry* next = it.Next()) {
[config setValue:[NSString stringWithUTF8String:next->value]
forKey:[NSString stringWithUTF8String:next->key]];
}
- Uploader *uploader =
+ Uploader* uploader =
[[[Uploader alloc] initWithConfig:config] autorelease];
- for (NSString *key in server_parameters) {
+ for (NSString* key in server_parameters) {
[uploader addServerParameter:[server_parameters objectForKey:key]
forKey:key];
}
@@ -567,11 +567,11 @@
}
//=============================================================================
-NSDictionary *Breakpad::GenerateReport(NSDictionary *server_parameters) {
- NSString *dumpDirAsNSString = KeyValue(@BREAKPAD_DUMP_DIRECTORY);
+NSDictionary* Breakpad::GenerateReport(NSDictionary* server_parameters) {
+ NSString* dumpDirAsNSString = KeyValue(@BREAKPAD_DUMP_DIRECTORY);
if (!dumpDirAsNSString)
return nil;
- const char *dumpDir = [dumpDirAsNSString UTF8String];
+ const char* dumpDir = [dumpDirAsNSString UTF8String];
google_breakpad::MinidumpGenerator generator(mach_task_self(),
MACH_PORT_NULL);
@@ -582,7 +582,7 @@
return nil;
LongStringDictionary params = *config_params_;
- for (NSString *key in server_parameters) {
+ for (NSString* key in server_parameters) {
params.SetKeyValue([key UTF8String],
[[server_parameters objectForKey:key] UTF8String]);
}
@@ -590,8 +590,8 @@
config_file.WriteFile(dumpDir, ¶ms, dumpDir, dumpId.c_str());
// Handle results.
- NSMutableDictionary *result = [NSMutableDictionary dictionary];
- NSString *dumpFullPath = [NSString stringWithUTF8String:dumpFilename.c_str()];
+ NSMutableDictionary* result = [NSMutableDictionary dictionary];
+ NSString* dumpFullPath = [NSString stringWithUTF8String:dumpFilename.c_str()];
[result setValue:dumpFullPath
forKey:@BREAKPAD_OUTPUT_DUMP_FILE];
[result setValue:[NSString stringWithUTF8String:config_file.GetFilePath()]
@@ -600,8 +600,8 @@
}
//=============================================================================
-bool Breakpad::HandleMinidump(const char *dump_dir,
- const char *minidump_id) {
+bool Breakpad::HandleMinidump(const char* dump_dir,
+ const char* minidump_id) {
config_file_.WriteFile(dump_dir,
config_params_,
dump_dir,
@@ -613,7 +613,7 @@
}
//=============================================================================
-void Breakpad::HandleUncaughtException(NSException *exception) {
+void Breakpad::HandleUncaughtException(NSException* exception) {
// Generate the minidump.
google_breakpad::IosExceptionMinidumpGenerator generator(exception);
const std::string minidump_path =
@@ -650,7 +650,7 @@
#pragma mark Public API
//=============================================================================
-BreakpadRef BreakpadCreate(NSDictionary *parameters) {
+BreakpadRef BreakpadCreate(NSDictionary* parameters) {
try {
// This is confusing. Our two main allocators for breakpad memory are:
// - gKeyValueAllocator for the key/value memory
@@ -690,8 +690,8 @@
ProtectedMemoryAllocator(breakpad_pool_size);
// Stack-based autorelease pool for Breakpad::Create() obj-c code.
- NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
- Breakpad *breakpad = Breakpad::Create(parameters);
+ NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+ Breakpad* breakpad = Breakpad::Create(parameters);
if (breakpad) {
// Make read-only to protect against memory smashers
@@ -731,7 +731,7 @@
//=============================================================================
void BreakpadRelease(BreakpadRef ref) {
try {
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (gMasterAllocator) {
gMasterAllocator->Unprotect();
@@ -764,10 +764,10 @@
}
//=============================================================================
-void BreakpadSetKeyValue(BreakpadRef ref, NSString *key, NSString *value) {
+void BreakpadSetKeyValue(BreakpadRef ref, NSString* key, NSString* value) {
try {
// Not called at exception time
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (breakpad && key && gKeyValueAllocator) {
ProtectedMemoryLocker locker(&gDictionaryMutex, gKeyValueAllocator);
@@ -780,20 +780,20 @@
}
void BreakpadAddUploadParameter(BreakpadRef ref,
- NSString *key,
- NSString *value) {
+ NSString* key,
+ NSString* value) {
// The only difference, internally, between an upload parameter and
// a key value one that is set with BreakpadSetKeyValue is that we
// prepend the keyname with a special prefix. This informs the
// crash sender that the parameter should be sent along with the
// POST of the crash dump upload.
try {
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (breakpad && key && gKeyValueAllocator) {
ProtectedMemoryLocker locker(&gDictionaryMutex, gKeyValueAllocator);
- NSString *prefixedKey = [@BREAKPAD_SERVER_PARAMETER_PREFIX
+ NSString* prefixedKey = [@BREAKPAD_SERVER_PARAMETER_PREFIX
stringByAppendingString:key];
breakpad->SetKeyValue(prefixedKey, value);
}
@@ -803,15 +803,15 @@
}
void BreakpadRemoveUploadParameter(BreakpadRef ref,
- NSString *key) {
+ NSString* key) {
try {
// Not called at exception time
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (breakpad && key && gKeyValueAllocator) {
ProtectedMemoryLocker locker(&gDictionaryMutex, gKeyValueAllocator);
- NSString *prefixedKey = [NSString stringWithFormat:@"%@%@",
+ NSString* prefixedKey = [NSString stringWithFormat:@"%@%@",
@BREAKPAD_SERVER_PARAMETER_PREFIX, key];
breakpad->RemoveKeyValue(prefixedKey);
}
@@ -820,12 +820,12 @@
}
}
//=============================================================================
-NSString *BreakpadKeyValue(BreakpadRef ref, NSString *key) {
- NSString *value = nil;
+NSString* BreakpadKeyValue(BreakpadRef ref, NSString* key) {
+ NSString* value = nil;
try {
// Not called at exception time
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (!breakpad || !key || !gKeyValueAllocator)
return nil;
@@ -841,10 +841,10 @@
}
//=============================================================================
-void BreakpadRemoveKeyValue(BreakpadRef ref, NSString *key) {
+void BreakpadRemoveKeyValue(BreakpadRef ref, NSString* key) {
try {
// Not called at exception time
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (breakpad && key && gKeyValueAllocator) {
ProtectedMemoryLocker locker(&gDictionaryMutex, gKeyValueAllocator);
@@ -860,7 +860,7 @@
int BreakpadGetCrashReportCount(BreakpadRef ref) {
try {
// Not called at exception time
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (breakpad) {
return static_cast<int>([breakpad->CrashReportsToUpload() count]);
@@ -877,9 +877,9 @@
}
//=============================================================================
-NSDictionary *BreakpadGetNextReportConfiguration(BreakpadRef ref) {
+NSDictionary* BreakpadGetNextReportConfiguration(BreakpadRef ref) {
try {
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (breakpad)
return breakpad->NextCrashReportConfiguration();
} catch(...) { // don't let exceptions leave this C API
@@ -889,9 +889,9 @@
}
//=============================================================================
-NSDate *BreakpadGetDateOfMostRecentCrashReport(BreakpadRef ref) {
+NSDate* BreakpadGetDateOfMostRecentCrashReport(BreakpadRef ref) {
try {
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (breakpad) {
return breakpad->DateOfMostRecentCrashReport();
}
@@ -904,11 +904,11 @@
//=============================================================================
void BreakpadUploadReportWithParametersAndConfiguration(
BreakpadRef ref,
- NSDictionary *server_parameters,
- NSDictionary *configuration,
+ NSDictionary* server_parameters,
+ NSDictionary* configuration,
BreakpadUploadCompletionCallback callback) {
try {
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (!breakpad || !configuration)
return;
breakpad->UploadReportWithConfiguration(configuration, server_parameters,
@@ -922,13 +922,13 @@
//=============================================================================
void BreakpadUploadNextReportWithParameters(
BreakpadRef ref,
- NSDictionary *server_parameters,
+ NSDictionary* server_parameters,
BreakpadUploadCompletionCallback callback) {
try {
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (!breakpad)
return;
- NSDictionary *configuration = breakpad->NextCrashReportConfiguration();
+ NSDictionary* configuration = breakpad->NextCrashReportConfiguration();
if (!configuration)
return;
return BreakpadUploadReportWithParametersAndConfiguration(
@@ -939,12 +939,12 @@
}
void BreakpadHandleNetworkResponse(BreakpadRef ref,
- NSDictionary *configuration,
- NSData *data,
- NSError *error) {
+ NSDictionary* configuration,
+ NSData* data,
+ NSError* error) {
try {
// Not called at exception time
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (breakpad && configuration)
breakpad->HandleNetworkResponse(configuration,data, error);
@@ -954,11 +954,11 @@
}
//=============================================================================
-void BreakpadUploadData(BreakpadRef ref, NSData *data, NSString *name,
- NSDictionary *server_parameters) {
+void BreakpadUploadData(BreakpadRef ref, NSData* data, NSString* name,
+ NSDictionary* server_parameters) {
try {
// Not called at exception time
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (breakpad) {
breakpad->UploadData(data, name, server_parameters);
@@ -969,11 +969,11 @@
}
//=============================================================================
-NSDictionary *BreakpadGenerateReport(BreakpadRef ref,
- NSDictionary *server_parameters) {
+NSDictionary* BreakpadGenerateReport(BreakpadRef ref,
+ NSDictionary* server_parameters) {
try {
// Not called at exception time
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (breakpad) {
return breakpad->GenerateReport(server_parameters);
diff --git a/src/client/ios/exception_handler_no_mach.cc b/src/client/ios/exception_handler_no_mach.cc
index 7fcf2d8..cb26449 100644
--- a/src/client/ios/exception_handler_no_mach.cc
+++ b/src/client/ios/exception_handler_no_mach.cc
@@ -47,7 +47,7 @@
// for more details.
#if USE_PROTECTED_ALLOCATIONS
#include "client/mac/handler/protected_memory_allocator.h"
- extern ProtectedMemoryAllocator *gBreakpadAllocator;
+ extern ProtectedMemoryAllocator* gBreakpadAllocator;
#endif
namespace google_breakpad {
@@ -72,10 +72,10 @@
char protected_buffer[PAGE_SIZE] __attribute__((aligned(PAGE_SIZE)));
#endif // defined PAGE_MAX_SIZE
#endif // USE_PROTECTED_ALLOCATIONS
- google_breakpad::ExceptionHandler *handler;
+ google_breakpad::ExceptionHandler* handler;
} gProtectedData;
-ExceptionHandler::ExceptionHandler(const string &dump_path,
+ExceptionHandler::ExceptionHandler(const string& dump_path,
FilterCallback filter,
MinidumpCallback callback,
void* callback_context,
diff --git a/src/client/ios/exception_handler_no_mach.h b/src/client/ios/exception_handler_no_mach.h
index 6d99565..ec598dc 100644
--- a/src/client/ios/exception_handler_no_mach.h
+++ b/src/client/ios/exception_handler_no_mach.h
@@ -53,7 +53,7 @@
// attempting to write a minidump. If a FilterCallback returns false, Breakpad
// will immediately report the exception as unhandled without writing a
// minidump, allowing another handler the opportunity to handle it.
- typedef bool (*FilterCallback)(void *context);
+ typedef bool (*FilterCallback)(void* context);
// A callback function to run after the minidump has been written.
// |minidump_id| is a unique id for the dump, so the minidump
@@ -63,18 +63,18 @@
// Return true if the exception was fully handled and breakpad should exit.
// Return false to allow any other exception handlers to process the
// exception.
- typedef bool (*MinidumpCallback)(const char *dump_dir,
- const char *minidump_id,
- void *context, bool succeeded);
+ typedef bool (*MinidumpCallback)(const char* dump_dir,
+ const char* minidump_id,
+ void* context, bool succeeded);
// A callback function which will be called directly if an exception occurs.
// This bypasses the minidump file writing and simply gives the client
// the exception information.
- typedef bool (*DirectCallback)( void *context,
- int exception_type,
- int exception_code,
- int exception_subcode,
- mach_port_t thread_name);
+ typedef bool (*DirectCallback)(void* context,
+ int exception_type,
+ int exception_code,
+ int exception_subcode,
+ mach_port_t thread_name);
// Creates a new ExceptionHandler instance to handle writing minidumps.
// Minidump files will be written to dump_path, and the optional callback
@@ -84,22 +84,22 @@
// be written when WriteMinidump is called.
// If port_name is non-NULL, attempt to perform out-of-process dump generation
// If port_name is NULL, in-process dump generation will be used.
- ExceptionHandler(const string &dump_path,
+ ExceptionHandler(const string& dump_path,
FilterCallback filter, MinidumpCallback callback,
- void *callback_context, bool install_handler,
- const char *port_name);
+ void* callback_context, bool install_handler,
+ const char* port_name);
// A special constructor if we want to bypass minidump writing and
// simply get a callback with the exception information.
ExceptionHandler(DirectCallback callback,
- void *callback_context,
+ void* callback_context,
bool install_handler);
~ExceptionHandler();
// Get and set the minidump path.
string dump_path() const { return dump_path_; }
- void set_dump_path(const string &dump_path) {
+ void set_dump_path(const string& dump_path) {
dump_path_ = dump_path;
dump_path_c_ = dump_path_.c_str();
UpdateNextID(); // Necessary to put dump_path_ in next_minidump_path_.
@@ -126,7 +126,7 @@
bool WriteMinidumpWithException(int exception_type,
int exception_code,
int exception_subcode,
- breakpad_ucontext_t *task_context,
+ breakpad_ucontext_t* task_context,
mach_port_t thread_name,
bool exit_after_write,
bool report_current_thread);
@@ -135,8 +135,8 @@
static void SignalHandler(int sig, siginfo_t* info, void* uc);
// disallow copy ctor and operator=
- explicit ExceptionHandler(const ExceptionHandler &);
- void operator=(const ExceptionHandler &);
+ explicit ExceptionHandler(const ExceptionHandler&);
+ void operator=(const ExceptionHandler&);
// Generates a new ID and stores it in next_minidump_id_, and stores the
// path of the next minidump to be written in next_minidump_path_.
@@ -152,15 +152,15 @@
string next_minidump_path_;
// Pointers to the UTF-8 versions of above
- const char *dump_path_c_;
- const char *next_minidump_id_c_;
- const char *next_minidump_path_c_;
+ const char* dump_path_c_;
+ const char* next_minidump_id_c_;
+ const char* next_minidump_path_c_;
// The callback function and pointer to be passed back after the minidump
// has been written
FilterCallback filter_;
MinidumpCallback callback_;
- void *callback_context_;
+ void* callback_context_;
// The callback function to be passed back when we don't want a minidump
// file to be written
diff --git a/src/client/ios/handler/ios_exception_minidump_generator.h b/src/client/ios/handler/ios_exception_minidump_generator.h
index 21133e6..e48444a 100644
--- a/src/client/ios/handler/ios_exception_minidump_generator.h
+++ b/src/client/ios/handler/ios_exception_minidump_generator.h
@@ -41,12 +41,12 @@
class IosExceptionMinidumpGenerator : public MinidumpGenerator {
public:
- explicit IosExceptionMinidumpGenerator(NSException *exception);
+ explicit IosExceptionMinidumpGenerator(NSException* exception);
virtual ~IosExceptionMinidumpGenerator();
protected:
- virtual bool WriteExceptionStream(MDRawDirectory *exception_stream);
- virtual bool WriteThreadStream(mach_port_t thread_id, MDRawThread *thread);
+ virtual bool WriteExceptionStream(MDRawDirectory* exception_stream);
+ virtual bool WriteThreadStream(mach_port_t thread_id, MDRawThread* thread);
private:
@@ -57,16 +57,16 @@
uintptr_t GetLRFromException();
// Write a virtual thread context for the crashing site.
- bool WriteCrashingContext(MDLocationDescriptor *register_location);
+ bool WriteCrashingContext(MDLocationDescriptor* register_location);
// Per-CPU implementations of the above method.
#ifdef HAS_ARM_SUPPORT
- bool WriteCrashingContextARM(MDLocationDescriptor *register_location);
+ bool WriteCrashingContextARM(MDLocationDescriptor* register_location);
#endif
#ifdef HAS_ARM64_SUPPORT
- bool WriteCrashingContextARM64(MDLocationDescriptor *register_location);
+ bool WriteCrashingContextARM64(MDLocationDescriptor* register_location);
#endif
- NSArray *return_addresses_;
+ NSArray* return_addresses_;
};
} // namespace google_breakpad
diff --git a/src/client/ios/handler/ios_exception_minidump_generator.mm b/src/client/ios/handler/ios_exception_minidump_generator.mm
index f57bdf2..2a5d76d 100644
--- a/src/client/ios/handler/ios_exception_minidump_generator.mm
+++ b/src/client/ios/handler/ios_exception_minidump_generator.mm
@@ -52,7 +52,7 @@
// Append the given value to the sp position of the stack represented
// by memory.
-void AppendToMemory(uint8_t *memory, uintptr_t sp, uintptr_t data) {
+void AppendToMemory(uint8_t* memory, uintptr_t sp, uintptr_t data) {
memcpy(memory + sp, &data, sizeof(data));
}
#endif
@@ -62,7 +62,7 @@
namespace google_breakpad {
IosExceptionMinidumpGenerator::IosExceptionMinidumpGenerator(
- NSException *exception)
+ NSException* exception)
: MinidumpGenerator(mach_task_self(), 0) {
return_addresses_ = [[exception callStackReturnAddresses] retain];
SetExceptionInformation(kExceptionType,
@@ -76,7 +76,7 @@
}
bool IosExceptionMinidumpGenerator::WriteCrashingContext(
- MDLocationDescriptor *register_location) {
+ MDLocationDescriptor* register_location) {
#ifdef HAS_ARM_SUPPORT
return WriteCrashingContextARM(register_location);
#elif defined(HAS_ARM64_SUPPORT)
@@ -89,12 +89,12 @@
#ifdef HAS_ARM_SUPPORT
bool IosExceptionMinidumpGenerator::WriteCrashingContextARM(
- MDLocationDescriptor *register_location) {
+ MDLocationDescriptor* register_location) {
TypedMDRVA<MDRawContextARM> context(&writer_);
if (!context.Allocate())
return false;
*register_location = context.location();
- MDRawContextARM *context_ptr = context.get();
+ MDRawContextARM* context_ptr = context.get();
memset(context_ptr, 0, sizeof(MDRawContextARM));
context_ptr->context_flags = MD_CONTEXT_ARM_FULL;
context_ptr->iregs[MD_CONTEXT_ARM_REG_IOS_FP] = kExpectedFinalFp; // FP
@@ -107,12 +107,12 @@
#ifdef HAS_ARM64_SUPPORT
bool IosExceptionMinidumpGenerator::WriteCrashingContextARM64(
- MDLocationDescriptor *register_location) {
+ MDLocationDescriptor* register_location) {
TypedMDRVA<MDRawContextARM64_Old> context(&writer_);
if (!context.Allocate())
return false;
*register_location = context.location();
- MDRawContextARM64_Old *context_ptr = context.get();
+ MDRawContextARM64_Old* context_ptr = context.get();
memset(context_ptr, 0, sizeof(*context_ptr));
context_ptr->context_flags = MD_CONTEXT_ARM64_FULL_OLD;
context_ptr->iregs[MD_CONTEXT_ARM64_REG_FP] = kExpectedFinalFp; // FP
@@ -132,7 +132,7 @@
}
bool IosExceptionMinidumpGenerator::WriteExceptionStream(
- MDRawDirectory *exception_stream) {
+ MDRawDirectory* exception_stream) {
#if defined(HAS_ARM_SUPPORT) || defined(HAS_ARM64_SUPPORT)
TypedMDRVA<MDRawExceptionStream> exception(&writer_);
@@ -141,7 +141,7 @@
exception_stream->stream_type = MD_EXCEPTION_STREAM;
exception_stream->location = exception.location();
- MDRawExceptionStream *exception_ptr = exception.get();
+ MDRawExceptionStream* exception_ptr = exception.get();
exception_ptr->thread_id = pthread_mach_thread_np(pthread_self());
// This naming is confusing, but it is the proper translation from
@@ -160,7 +160,7 @@
}
bool IosExceptionMinidumpGenerator::WriteThreadStream(mach_port_t thread_id,
- MDRawThread *thread) {
+ MDRawThread* thread) {
#if defined(HAS_ARM_SUPPORT) || defined(HAS_ARM64_SUPPORT)
if (pthread_mach_thread_np(pthread_self()) != thread_id)
return MinidumpGenerator::WriteThreadStream(thread_id, thread);
diff --git a/src/client/linux/crash_generation/crash_generation_server.cc b/src/client/linux/crash_generation/crash_generation_server.cc
index 26c50a5..8332f59 100644
--- a/src/client/linux/crash_generation/crash_generation_server.cc
+++ b/src/client/linux/crash_generation/crash_generation_server.cc
@@ -229,7 +229,7 @@
// Walk the control payload and extract the file descriptor and validated pid.
pid_t crashing_pid = -1;
int signal_fd = -1;
- for (struct cmsghdr *hdr = CMSG_FIRSTHDR(&msg); hdr;
+ for (struct cmsghdr* hdr = CMSG_FIRSTHDR(&msg); hdr;
hdr = CMSG_NXTHDR(&msg, hdr)) {
if (hdr->cmsg_level != SOL_SOCKET)
continue;
@@ -248,7 +248,7 @@
signal_fd = reinterpret_cast<int*>(CMSG_DATA(hdr))[0];
}
} else if (hdr->cmsg_type == SCM_CREDENTIALS) {
- const struct ucred *cred =
+ const struct ucred* cred =
reinterpret_cast<struct ucred*>(CMSG_DATA(hdr));
crashing_pid = cred->pid;
}
@@ -324,7 +324,7 @@
// static
void*
-CrashGenerationServer::ThreadMain(void *arg)
+CrashGenerationServer::ThreadMain(void* arg)
{
reinterpret_cast<CrashGenerationServer*>(arg)->Run();
return NULL;
diff --git a/src/client/linux/dump_writer_common/ucontext_reader.cc b/src/client/linux/dump_writer_common/ucontext_reader.cc
index ee515c4..6eec1be 100644
--- a/src/client/linux/dump_writer_common/ucontext_reader.cc
+++ b/src/client/linux/dump_writer_common/ucontext_reader.cc
@@ -48,7 +48,7 @@
return uc->uc_mcontext.gregs[REG_EIP];
}
-void UContextReader::FillCPUContext(RawContextCPU *out, const ucontext_t *uc,
+void UContextReader::FillCPUContext(RawContextCPU* out, const ucontext_t* uc,
const fpstate_t* fp) {
const greg_t* regs = uc->uc_mcontext.gregs;
@@ -96,7 +96,7 @@
return uc->uc_mcontext.gregs[REG_RIP];
}
-void UContextReader::FillCPUContext(RawContextCPU *out, const ucontext_t *uc,
+void UContextReader::FillCPUContext(RawContextCPU* out, const ucontext_t* uc,
const fpstate_t* fpregs) {
const greg_t* regs = uc->uc_mcontext.gregs;
@@ -153,7 +153,7 @@
return uc->uc_mcontext.arm_pc;
}
-void UContextReader::FillCPUContext(RawContextCPU *out, const ucontext_t *uc) {
+void UContextReader::FillCPUContext(RawContextCPU* out, const ucontext_t* uc) {
out->context_flags = MD_CONTEXT_ARM_FULL;
out->iregs[0] = uc->uc_mcontext.arm_r0;
@@ -192,7 +192,7 @@
return uc->uc_mcontext.pc;
}
-void UContextReader::FillCPUContext(RawContextCPU *out, const ucontext_t *uc,
+void UContextReader::FillCPUContext(RawContextCPU* out, const ucontext_t* uc,
const struct fpsimd_context* fpregs) {
out->context_flags = MD_CONTEXT_ARM64_FULL_OLD;
@@ -218,7 +218,7 @@
return uc->uc_mcontext.pc;
}
-void UContextReader::FillCPUContext(RawContextCPU *out, const ucontext_t *uc) {
+void UContextReader::FillCPUContext(RawContextCPU* out, const ucontext_t* uc) {
#if _MIPS_SIM == _ABI64
out->context_flags = MD_CONTEXT_MIPS64_FULL;
#elif _MIPS_SIM == _ABIO32
diff --git a/src/client/linux/dump_writer_common/ucontext_reader.h b/src/client/linux/dump_writer_common/ucontext_reader.h
index 8e74a8a..7d41008 100644
--- a/src/client/linux/dump_writer_common/ucontext_reader.h
+++ b/src/client/linux/dump_writer_common/ucontext_reader.h
@@ -50,13 +50,13 @@
// out: the minidump structure
// info: the collection of register structures.
#if defined(__i386__) || defined(__x86_64)
- static void FillCPUContext(RawContextCPU *out, const ucontext_t *uc,
+ static void FillCPUContext(RawContextCPU* out, const ucontext_t* uc,
const fpstate_t* fp);
#elif defined(__aarch64__)
- static void FillCPUContext(RawContextCPU *out, const ucontext_t *uc,
+ static void FillCPUContext(RawContextCPU* out, const ucontext_t* uc,
const struct fpsimd_context* fpregs);
#else
- static void FillCPUContext(RawContextCPU *out, const ucontext_t *uc);
+ static void FillCPUContext(RawContextCPU* out, const ucontext_t* uc);
#endif
};
diff --git a/src/client/linux/handler/exception_handler.cc b/src/client/linux/handler/exception_handler.cc
index c65feaa..ca353c4 100644
--- a/src/client/linux/handler/exception_handler.cc
+++ b/src/client/linux/handler/exception_handler.cc
@@ -419,8 +419,8 @@
// This is the entry function for the cloned process. We are in a compromised
// context here: see the top of the file.
// static
-int ExceptionHandler::ThreadEntry(void *arg) {
- const ThreadArgument *thread_arg = reinterpret_cast<ThreadArgument*>(arg);
+int ExceptionHandler::ThreadEntry(void* arg) {
+ const ThreadArgument* thread_arg = reinterpret_cast<ThreadArgument*>(arg);
// Close the write end of the pipe. This allows us to fail if the parent dies
// while waiting for the continue signal.
@@ -495,7 +495,7 @@
}
// This function may run in a compromised context: see the top of the file.
-bool ExceptionHandler::GenerateDump(CrashContext *context) {
+bool ExceptionHandler::GenerateDump(CrashContext* context) {
if (IsOutOfProcess())
return crash_generation_client_->RequestDump(context, sizeof(*context));
diff --git a/src/client/linux/handler/exception_handler.h b/src/client/linux/handler/exception_handler.h
index f44483f..f80843e 100644
--- a/src/client/linux/handler/exception_handler.h
+++ b/src/client/linux/handler/exception_handler.h
@@ -82,7 +82,7 @@
// attempting to write a minidump. If a FilterCallback returns false,
// Breakpad will immediately report the exception as unhandled without
// writing a minidump, allowing another handler the opportunity to handle it.
- typedef bool (*FilterCallback)(void *context);
+ typedef bool (*FilterCallback)(void* context);
// A callback function to run after the minidump has been written.
// |descriptor| contains the file descriptor or file path containing the
@@ -234,7 +234,7 @@
static void RestoreHandlersLocked();
void PreresolveSymbols();
- bool GenerateDump(CrashContext *context);
+ bool GenerateDump(CrashContext* context);
void SendContinueSignalToChild();
void WaitForContinueSignal();
diff --git a/src/client/linux/handler/exception_handler_unittest.cc b/src/client/linux/handler/exception_handler_unittest.cc
index 8d8809f..35dcbfd 100644
--- a/src/client/linux/handler/exception_handler_unittest.cc
+++ b/src/client/linux/handler/exception_handler_unittest.cc
@@ -201,7 +201,7 @@
// optimize them out. In the case of ExceptionHandlerTest::ExternalDumper,
// GCC-4.9 optimized out the entire set up of ExceptionHandler, causing
// test failure.
-volatile int *p_null; // external linkage, so GCC can't tell that it
+volatile int* p_null; // external linkage, so GCC can't tell that it
// remains NULL. Volatile just for a good measure.
static void DoNullPointerDereference() {
*p_null = 1;
@@ -994,7 +994,7 @@
msg.msg_control = cmsg;
msg.msg_controllen = sizeof(cmsg);
- struct cmsghdr *hdr = CMSG_FIRSTHDR(&msg);
+ struct cmsghdr* hdr = CMSG_FIRSTHDR(&msg);
hdr->cmsg_level = SOL_SOCKET;
hdr->cmsg_type = SCM_RIGHTS;
hdr->cmsg_len = CMSG_LEN(sizeof(int));
@@ -1003,7 +1003,7 @@
hdr->cmsg_level = SOL_SOCKET;
hdr->cmsg_type = SCM_CREDENTIALS;
hdr->cmsg_len = CMSG_LEN(sizeof(struct ucred));
- struct ucred *cred = reinterpret_cast<struct ucred*>(CMSG_DATA(hdr));
+ struct ucred* cred = reinterpret_cast<struct ucred*>(CMSG_DATA(hdr));
cred->uid = getuid();
cred->gid = getgid();
cred->pid = getpid();
@@ -1056,7 +1056,7 @@
pid_t crashing_pid = -1;
int signal_fd = -1;
- for (struct cmsghdr *hdr = CMSG_FIRSTHDR(&msg); hdr;
+ for (struct cmsghdr* hdr = CMSG_FIRSTHDR(&msg); hdr;
hdr = CMSG_NXTHDR(&msg, hdr)) {
if (hdr->cmsg_level != SOL_SOCKET)
continue;
@@ -1066,7 +1066,7 @@
ASSERT_EQ(sizeof(int), len);
signal_fd = *(reinterpret_cast<int*>(CMSG_DATA(hdr)));
} else if (hdr->cmsg_type == SCM_CREDENTIALS) {
- const struct ucred *cred =
+ const struct ucred* cred =
reinterpret_cast<struct ucred*>(CMSG_DATA(hdr));
crashing_pid = cred->pid;
}
diff --git a/src/client/linux/log/log.cc b/src/client/linux/log/log.cc
index fc23aa6..3187940 100644
--- a/src/client/linux/log/log.cc
+++ b/src/client/linux/log/log.cc
@@ -44,8 +44,8 @@
// __android_log_buf_write() is not exported in the NDK and is being used by
// dynamic runtime linking. Its declaration is taken from Android's
// system/core/include/log/log.h.
-using AndroidLogBufferWriteFunc = int (*)(int bufID, int prio, const char *tag,
- const char *text);
+using AndroidLogBufferWriteFunc = int (*)(int bufID, int prio, const char* tag,
+ const char* text);
const int kAndroidCrashLogId = 4; // From LOG_ID_CRASH in log.h.
const char kAndroidLogTag[] = "google-breakpad";
diff --git a/src/client/linux/minidump_writer/directory_reader_unittest.cc b/src/client/linux/minidump_writer/directory_reader_unittest.cc
index 326f9e3..7292a63 100644
--- a/src/client/linux/minidump_writer/directory_reader_unittest.cc
+++ b/src/client/linux/minidump_writer/directory_reader_unittest.cc
@@ -47,7 +47,7 @@
TEST(DirectoryReaderTest, CompareResults) {
std::set<string> dent_set;
- DIR *const dir = opendir("/proc/self");
+ DIR* const dir = opendir("/proc/self");
ASSERT_TRUE(dir != NULL);
struct dirent* dent;
diff --git a/src/client/linux/minidump_writer/line_reader.h b/src/client/linux/minidump_writer/line_reader.h
index 779cfeb..9fc4b7c 100644
--- a/src/client/linux/minidump_writer/line_reader.h
+++ b/src/client/linux/minidump_writer/line_reader.h
@@ -61,7 +61,7 @@
//
// One must call |PopLine| after this function, otherwise you'll continue to
// get the same line over and over.
- bool GetNextLine(const char **line, unsigned *len) {
+ bool GetNextLine(const char** line, unsigned* len) {
for (;;) {
if (buf_used_ == 0 && hit_eof_)
return false;
diff --git a/src/client/linux/minidump_writer/line_reader_unittest.cc b/src/client/linux/minidump_writer/line_reader_unittest.cc
index 29686f0..e1ac445 100644
--- a/src/client/linux/minidump_writer/line_reader_unittest.cc
+++ b/src/client/linux/minidump_writer/line_reader_unittest.cc
@@ -59,7 +59,7 @@
ASSERT_TRUE(file.IsOk());
LineReader reader(file.GetFd());
- const char *line;
+ const char* line;
unsigned len;
ASSERT_FALSE(reader.GetNextLine(&line, &len));
}
@@ -69,7 +69,7 @@
ASSERT_TRUE(file.IsOk());
LineReader reader(file.GetFd());
- const char *line;
+ const char* line;
unsigned int len;
ASSERT_TRUE(reader.GetNextLine(&line, &len));
ASSERT_EQ((unsigned int)1, len);
@@ -85,7 +85,7 @@
ASSERT_TRUE(file.IsOk());
LineReader reader(file.GetFd());
- const char *line;
+ const char* line;
unsigned len;
ASSERT_TRUE(reader.GetNextLine(&line, &len));
ASSERT_EQ((unsigned)1, len);
@@ -101,7 +101,7 @@
ASSERT_TRUE(file.IsOk());
LineReader reader(file.GetFd());
- const char *line;
+ const char* line;
unsigned len;
ASSERT_TRUE(reader.GetNextLine(&line, &len));
ASSERT_EQ((unsigned)1, len);
@@ -123,7 +123,7 @@
ASSERT_TRUE(file.IsOk());
LineReader reader(file.GetFd());
- const char *line;
+ const char* line;
unsigned len;
ASSERT_TRUE(reader.GetNextLine(&line, &len));
ASSERT_EQ((unsigned)1, len);
@@ -147,7 +147,7 @@
ASSERT_TRUE(file.IsOk());
LineReader reader(file.GetFd());
- const char *line;
+ const char* line;
unsigned len;
ASSERT_TRUE(reader.GetNextLine(&line, &len));
ASSERT_EQ(sizeof(l), len);
@@ -163,7 +163,7 @@
ASSERT_TRUE(file.IsOk());
LineReader reader(file.GetFd());
- const char *line;
+ const char* line;
unsigned len;
ASSERT_FALSE(reader.GetNextLine(&line, &len));
}
diff --git a/src/client/linux/minidump_writer/linux_dumper.cc b/src/client/linux/minidump_writer/linux_dumper.cc
index 1112035..7fd6532 100644
--- a/src/client/linux/minidump_writer/linux_dumper.cc
+++ b/src/client/linux/minidump_writer/linux_dumper.cc
@@ -135,7 +135,7 @@
// next is backed by some file.
// curr and next are contiguous.
// offset(next) == sizeof(curr)
-void TryRecoverMappings(MappingInfo *curr, MappingInfo *next) {
+void TryRecoverMappings(MappingInfo* curr, MappingInfo* next) {
// Merged segments are marked with size = 0.
if (curr->size == 0 || next->size == 0)
return;
@@ -167,8 +167,8 @@
// next and prev are backed by the same file.
// prev, curr and next are contiguous.
// offset(next) == offset(prev) + sizeof(prev) + sizeof(curr)
-void TryRecoverMappings(MappingInfo *prev, MappingInfo *curr,
- MappingInfo *next) {
+void TryRecoverMappings(MappingInfo* prev, MappingInfo* curr,
+ MappingInfo* next) {
// Merged segments are marked with size = 0.
if (prev->size == 0 || curr->size == 0 || next->size == 0)
return;
@@ -551,11 +551,11 @@
// See http://www.trilithium.com/johan/2005/08/linux-gate/ for more
// information.
const void* linux_gate_loc =
- reinterpret_cast<void *>(auxv_[AT_SYSINFO_EHDR]);
+ reinterpret_cast<void*>(auxv_[AT_SYSINFO_EHDR]);
// Although the initial executable is usually the first mapping, it's not
// guaranteed (see http://crosbug.com/25355); therefore, try to use the
// actual entry point to find the mapping.
- const void* entry_point_loc = reinterpret_cast<void *>(auxv_[AT_ENTRY]);
+ const void* entry_point_loc = reinterpret_cast<void*>(auxv_[AT_ENTRY]);
const int fd = sys_open(maps_path, O_RDONLY, 0);
if (fd < 0)
diff --git a/src/client/linux/minidump_writer/linux_dumper.h b/src/client/linux/minidump_writer/linux_dumper.h
index f4a75d9..7bee160 100644
--- a/src/client/linux/minidump_writer/linux_dumper.h
+++ b/src/client/linux/minidump_writer/linux_dumper.h
@@ -110,8 +110,8 @@
}
// These are only valid after a call to |Init|.
- const wasteful_vector<pid_t> &threads() { return threads_; }
- const wasteful_vector<MappingInfo*> &mappings() { return mappings_; }
+ const wasteful_vector<pid_t>& threads() { return threads_; }
+ const wasteful_vector<MappingInfo*>& mappings() { return mappings_; }
const MappingInfo* FindMapping(const void* address) const;
// Find the mapping which the given memory address falls in. Unlike
// FindMapping, this method uses the unadjusted mapping address
diff --git a/src/client/linux/minidump_writer/linux_dumper_unittest_helper.cc b/src/client/linux/minidump_writer/linux_dumper_unittest_helper.cc
index 3ad48e5..331f4bb 100644
--- a/src/client/linux/minidump_writer/linux_dumper_unittest_helper.cc
+++ b/src/client/linux/minidump_writer/linux_dumper_unittest_helper.cc
@@ -55,8 +55,8 @@
#error This test has not been ported to this platform.
#endif
-void *thread_function(void *data) {
- int pipefd = *static_cast<int *>(data);
+void* thread_function(void* data) {
+ int pipefd = *static_cast<int*>(data);
volatile pid_t* thread_id = new pid_t;
*thread_id = syscall(__NR_gettid);
// Signal parent that a thread has started.
@@ -65,13 +65,13 @@
perror("ERROR: parent notification failed");
return NULL;
}
- register volatile pid_t *thread_id_ptr asm(TID_PTR_REGISTER) = thread_id;
+ register volatile pid_t* thread_id_ptr asm(TID_PTR_REGISTER) = thread_id;
while (true)
asm volatile ("" : : "r" (thread_id_ptr));
return NULL;
}
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
if (argc < 3) {
fprintf(stderr,
"usage: linux_dumper_unittest_helper <pipe fd> <# of threads>\n");
diff --git a/src/client/linux/minidump_writer/linux_ptrace_dumper_unittest.cc b/src/client/linux/minidump_writer/linux_ptrace_dumper_unittest.cc
index ea6b9a1..da71e15 100644
--- a/src/client/linux/minidump_writer/linux_ptrace_dumper_unittest.cc
+++ b/src/client/linux/minidump_writer/linux_ptrace_dumper_unittest.cc
@@ -337,7 +337,7 @@
ASSERT_TRUE(dumper.Init());
void* linux_gate_loc =
- reinterpret_cast<void *>(dumper.auxv()[AT_SYSINFO_EHDR]);
+ reinterpret_cast<void*>(dumper.auxv()[AT_SYSINFO_EHDR]);
ASSERT_TRUE(linux_gate_loc);
bool found_linux_gate = false;
diff --git a/src/client/linux/minidump_writer/minidump_writer.cc b/src/client/linux/minidump_writer/minidump_writer.cc
index f8cdf2a..32634ef 100644
--- a/src/client/linux/minidump_writer/minidump_writer.cc
+++ b/src/client/linux/minidump_writer/minidump_writer.cc
@@ -740,14 +740,14 @@
}
bool WriteDSODebugStream(MDRawDirectory* dirent) {
- ElfW(Phdr)* phdr = reinterpret_cast<ElfW(Phdr) *>(dumper_->auxv()[AT_PHDR]);
+ ElfW(Phdr)* phdr = reinterpret_cast<ElfW(Phdr)*>(dumper_->auxv()[AT_PHDR]);
char* base;
int phnum = dumper_->auxv()[AT_PHNUM];
if (!phnum || !phdr)
return false;
// Assume the program base is at the beginning of the same page as the PHDR
- base = reinterpret_cast<char *>(reinterpret_cast<uintptr_t>(phdr) & ~0xfff);
+ base = reinterpret_cast<char*>(reinterpret_cast<uintptr_t>(phdr) & ~0xfff);
// Search for the program PT_DYNAMIC segment
ElfW(Addr) dyn_addr = 0;
@@ -768,7 +768,7 @@
if (!dyn_addr)
return false;
- ElfW(Dyn) *dynamic = reinterpret_cast<ElfW(Dyn) *>(dyn_addr + base);
+ ElfW(Dyn)* dynamic = reinterpret_cast<ElfW(Dyn)*>(dyn_addr + base);
// The dynamic linker makes information available that helps gdb find all
// DSOs loaded into the program. If this information is indeed available,
@@ -1222,7 +1222,7 @@
Buffers* next;
size_t len;
uint8_t data[kBufSize];
- } *buffers = reinterpret_cast<Buffers*>(Alloc(sizeof(Buffers)));
+ }* buffers = reinterpret_cast<Buffers*>(Alloc(sizeof(Buffers)));
buffers->next = NULL;
buffers->len = 0;
diff --git a/src/client/linux/minidump_writer/minidump_writer_unittest.cc b/src/client/linux/minidump_writer/minidump_writer_unittest.cc
index 3017a49..ac93a34 100644
--- a/src/client/linux/minidump_writer/minidump_writer_unittest.cc
+++ b/src/client/linux/minidump_writer/minidump_writer_unittest.cc
@@ -299,10 +299,10 @@
Minidump minidump(templ);
ASSERT_TRUE(minidump.Read());
- MinidumpThreadList *threads = minidump.GetThreadList();
+ MinidumpThreadList* threads = minidump.GetThreadList();
int threads_with_stacks = 0;
for (unsigned int i = 0; i < threads->thread_count(); ++i) {
- MinidumpThread *thread = threads->GetThreadAtIndex(i);
+ MinidumpThread* thread = threads->GetThreadAtIndex(i);
if (thread->GetMemory()) {
++threads_with_stacks;
}
@@ -353,13 +353,13 @@
#else
0x0defaced;
#endif
- MinidumpThreadList *threads = minidump.GetThreadList();
+ MinidumpThreadList* threads = minidump.GetThreadList();
for (unsigned int i = 0; i < threads->thread_count(); ++i) {
- MinidumpThread *thread = threads->GetThreadAtIndex(i);
- MinidumpMemoryRegion *mem = thread->GetMemory();
+ MinidumpThread* thread = threads->GetThreadAtIndex(i);
+ MinidumpMemoryRegion* mem = thread->GetMemory();
ASSERT_TRUE(mem != nullptr);
uint32_t sz = mem->GetSize();
- const uint8_t *data = mem->GetMemory();
+ const uint8_t* data = mem->GetMemory();
ASSERT_TRUE(memmem(data, sz, &defaced, sizeof(defaced)) != nullptr);
}
close(fds[1]);
diff --git a/src/client/linux/minidump_writer/minidump_writer_unittest_utils.cc b/src/client/linux/minidump_writer/minidump_writer_unittest_utils.cc
index 9f46fa6..8e2319e 100644
--- a/src/client/linux/minidump_writer/minidump_writer_unittest_utils.cc
+++ b/src/client/linux/minidump_writer/minidump_writer_unittest_utils.cc
@@ -41,7 +41,7 @@
string GetHelperBinary() {
string helper_path;
- char *bindir = getenv("bindir");
+ char* bindir = getenv("bindir");
if (bindir) {
helper_path = string(bindir) + "/";
} else {
diff --git a/src/client/linux/minidump_writer/proc_cpuinfo_reader_unittest.cc b/src/client/linux/minidump_writer/proc_cpuinfo_reader_unittest.cc
index 6037c7e..d9b1203 100644
--- a/src/client/linux/minidump_writer/proc_cpuinfo_reader_unittest.cc
+++ b/src/client/linux/minidump_writer/proc_cpuinfo_reader_unittest.cc
@@ -65,7 +65,7 @@
ASSERT_TRUE(file.IsOk());
ProcCpuInfoReader reader(file.GetFd());
- const char *field;
+ const char* field;
ASSERT_FALSE(reader.GetNextField(&field));
}
@@ -74,7 +74,7 @@
ASSERT_TRUE(file.IsOk());
ProcCpuInfoReader reader(file.GetFd());
- const char *field;
+ const char* field;
ASSERT_TRUE(reader.GetNextField(&field));
ASSERT_STREQ("foo", field);
ASSERT_STREQ("bar", reader.GetValue());
@@ -87,7 +87,7 @@
ASSERT_TRUE(file.IsOk());
ProcCpuInfoReader reader(file.GetFd());
- const char *field;
+ const char* field;
size_t value_len;
ASSERT_TRUE(reader.GetNextField(&field));
ASSERT_STREQ("foo", field);
diff --git a/src/client/linux/sender/google_crash_report_sender.cc b/src/client/linux/sender/google_crash_report_sender.cc
index f83a0e8..6bf337a 100644
--- a/src/client/linux/sender/google_crash_report_sender.cc
+++ b/src/client/linux/sender/google_crash_report_sender.cc
@@ -84,7 +84,7 @@
return true;
}
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
google::InitGoogleLogging(argv[0]);
google::ParseCommandLineFlags(&argc, &argv, true);
if (!CheckForRequiredFlagsOrDie()) {
diff --git a/src/client/mac/Framework/Breakpad.h b/src/client/mac/Framework/Breakpad.h
index dc7e45d..9e191ce 100644
--- a/src/client/mac/Framework/Breakpad.h
+++ b/src/client/mac/Framework/Breakpad.h
@@ -45,7 +45,7 @@
// OnDemandServer and restored in Inspector.
#define BREAKPAD_BOOTSTRAP_PARENT_PORT "com.Breakpad.BootstrapParent"
-typedef void *BreakpadRef;
+typedef void* BreakpadRef;
#ifdef __cplusplus
extern "C" {
@@ -65,7 +65,7 @@
typedef bool (*BreakpadFilterCallback)(int exception_type,
int exception_code,
mach_port_t crashing_thread,
- void *context);
+ void* context);
// Create a new BreakpadRef object and install it as an exception
// handler. The |parameters| will typically be the contents of your
@@ -226,7 +226,7 @@
// Only used in crash_report_sender.
// Returns a new BreakpadRef object on success, NULL otherwise.
-BreakpadRef BreakpadCreate(NSDictionary *parameters);
+BreakpadRef BreakpadCreate(NSDictionary* parameters);
// Uninstall and release the data associated with |ref|.
void BreakpadRelease(BreakpadRef ref);
@@ -238,7 +238,7 @@
// Context is a pointer to arbitrary data to make the callback with.
void BreakpadSetFilterCallback(BreakpadRef ref,
BreakpadFilterCallback callback,
- void *context);
+ void* context);
// User defined key and value string storage. Generally this is used
// to configure Breakpad's internal operation, such as whether the
@@ -259,23 +259,23 @@
// TODO (nealsid): separate server parameter dictionary from the
// dictionary used to configure Breakpad, and document limits for each
// independently.
-void BreakpadSetKeyValue(BreakpadRef ref, NSString *key, NSString *value);
-NSString *BreakpadKeyValue(BreakpadRef ref, NSString *key);
-void BreakpadRemoveKeyValue(BreakpadRef ref, NSString *key);
+void BreakpadSetKeyValue(BreakpadRef ref, NSString* key, NSString* value);
+NSString* BreakpadKeyValue(BreakpadRef ref, NSString* key);
+void BreakpadRemoveKeyValue(BreakpadRef ref, NSString* key);
// You can use this method to specify parameters that will be uploaded
// to the crash server. They will be automatically encoded as
// necessary. Note that as mentioned above there are limits on both
// the number of keys and their length.
-void BreakpadAddUploadParameter(BreakpadRef ref, NSString *key,
- NSString *value);
+void BreakpadAddUploadParameter(BreakpadRef ref, NSString* key,
+ NSString* value);
// This method will remove a previously-added parameter from the
// upload parameter set.
-void BreakpadRemoveUploadParameter(BreakpadRef ref, NSString *key);
+void BreakpadRemoveUploadParameter(BreakpadRef ref, NSString* key);
// Add a log file for Breakpad to read and send upon crash dump
-void BreakpadAddLogFile(BreakpadRef ref, NSString *logPathname);
+void BreakpadAddLogFile(BreakpadRef ref, NSString* logPathname);
// Generate a minidump and send
void BreakpadGenerateAndSendReport(BreakpadRef ref);
diff --git a/src/client/mac/Framework/Breakpad.mm b/src/client/mac/Framework/Breakpad.mm
index b214054..1a46b59 100644
--- a/src/client/mac/Framework/Breakpad.mm
+++ b/src/client/mac/Framework/Breakpad.mm
@@ -81,9 +81,9 @@
// allocation of C++ objects. Note that we don't use operator delete()
// but instead call the objects destructor directly: object->~ClassName();
//
-ProtectedMemoryAllocator *gMasterAllocator = NULL;
-ProtectedMemoryAllocator *gKeyValueAllocator = NULL;
-ProtectedMemoryAllocator *gBreakpadAllocator = NULL;
+ProtectedMemoryAllocator* gMasterAllocator = NULL;
+ProtectedMemoryAllocator* gKeyValueAllocator = NULL;
+ProtectedMemoryAllocator* gBreakpadAllocator = NULL;
// Mutex for thread-safe access to the key/value dictionary used by breakpad.
// It's a global instead of an instance variable of Breakpad
@@ -98,8 +98,8 @@
// Its destructor will first re-protect the memory then release the lock.
class ProtectedMemoryLocker {
public:
- ProtectedMemoryLocker(pthread_mutex_t *mutex,
- ProtectedMemoryAllocator *allocator)
+ ProtectedMemoryLocker(pthread_mutex_t* mutex,
+ ProtectedMemoryAllocator* allocator)
: mutex_(mutex),
allocator_(allocator) {
// Lock the mutex
@@ -124,17 +124,17 @@
ProtectedMemoryLocker(const ProtectedMemoryLocker&);
ProtectedMemoryLocker& operator=(const ProtectedMemoryLocker&);
- pthread_mutex_t *mutex_;
- ProtectedMemoryAllocator *allocator_;
+ pthread_mutex_t* mutex_;
+ ProtectedMemoryAllocator* allocator_;
};
//=============================================================================
class Breakpad {
public:
// factory method
- static Breakpad *Create(NSDictionary *parameters) {
+ static Breakpad* Create(NSDictionary* parameters) {
// Allocate from our special allocation pool
- Breakpad *breakpad =
+ Breakpad* breakpad =
new (gBreakpadAllocator->Allocate(sizeof(Breakpad)))
Breakpad();
@@ -152,13 +152,13 @@
~Breakpad();
- void SetKeyValue(NSString *key, NSString *value);
- NSString *KeyValue(NSString *key);
- void RemoveKeyValue(NSString *key);
+ void SetKeyValue(NSString* key, NSString* value);
+ NSString* KeyValue(NSString* key);
+ void RemoveKeyValue(NSString* key);
void GenerateAndSendReport();
- void SetFilterCallback(BreakpadFilterCallback callback, void *context) {
+ void SetFilterCallback(BreakpadFilterCallback callback, void* context) {
filter_callback_ = callback;
filter_callback_context_ = context;
}
@@ -173,14 +173,14 @@
inspector_path_[0] = 0;
}
- bool Initialize(NSDictionary *parameters);
- bool InitializeInProcess(NSDictionary *parameters);
- bool InitializeOutOfProcess(NSDictionary *parameters);
+ bool Initialize(NSDictionary* parameters);
+ bool InitializeInProcess(NSDictionary* parameters);
+ bool InitializeOutOfProcess(NSDictionary* parameters);
- bool ExtractParameters(NSDictionary *parameters);
+ bool ExtractParameters(NSDictionary* parameters);
// Dispatches to HandleException()
- static bool ExceptionHandlerDirectCallback(void *context,
+ static bool ExceptionHandlerDirectCallback(void* context,
int exception_type,
int exception_code,
int exception_subcode,
@@ -194,28 +194,28 @@
// Dispatches to HandleMinidump().
// This gets called instead of ExceptionHandlerDirectCallback when running
// with the BREAKPAD_IN_PROCESS option.
- static bool HandleMinidumpCallback(const char *dump_dir,
- const char *minidump_id,
- void *context,
+ static bool HandleMinidumpCallback(const char* dump_dir,
+ const char* minidump_id,
+ void* context,
bool succeeded);
// This is only used when BREAKPAD_IN_PROCESS is YES.
- bool HandleMinidump(const char *dump_dir, const char *minidump_id);
+ bool HandleMinidump(const char* dump_dir, const char* minidump_id);
// Since ExceptionHandler (w/o namespace) is defined as typedef in OSX's
// MachineExceptions.h, we have to explicitly name the handler.
- google_breakpad::ExceptionHandler *handler_; // The actual handler (STRONG)
+ google_breakpad::ExceptionHandler* handler_; // The actual handler (STRONG)
char inspector_path_[PATH_MAX]; // Path to inspector tool
- SimpleStringDictionary *config_params_; // Create parameters (STRONG)
+ SimpleStringDictionary* config_params_; // Create parameters (STRONG)
OnDemandServer inspector_;
bool send_and_exit_; // Exit after sending, if true
BreakpadFilterCallback filter_callback_;
- void *filter_callback_context_;
+ void* filter_callback_context_;
};
#pragma mark -
@@ -227,14 +227,14 @@
//=============================================================================
static BOOL IsDebuggerActive() {
BOOL result = NO;
- NSUserDefaults *stdDefaults = [NSUserDefaults standardUserDefaults];
+ NSUserDefaults* stdDefaults = [NSUserDefaults standardUserDefaults];
// We check both defaults and the environment variable here
BOOL ignoreDebugger = [stdDefaults boolForKey:@IGNORE_DEBUGGER];
if (!ignoreDebugger) {
- char *ignoreDebuggerStr = getenv(IGNORE_DEBUGGER);
+ char* ignoreDebuggerStr = getenv(IGNORE_DEBUGGER);
ignoreDebugger = (ignoreDebuggerStr ? strtol(ignoreDebuggerStr, NULL, 10) : 0) != 0;
}
@@ -245,7 +245,7 @@
size_t actualSize;
if (sysctl(mib, mibSize, NULL, &actualSize, NULL, 0) == 0) {
- struct kinfo_proc *info = (struct kinfo_proc *)malloc(actualSize);
+ struct kinfo_proc* info = (struct kinfo_proc*)malloc(actualSize);
if (info) {
// This comes from looking at the Darwin xnu Kernel
@@ -261,12 +261,12 @@
}
//=============================================================================
-bool Breakpad::ExceptionHandlerDirectCallback(void *context,
- int exception_type,
- int exception_code,
- int exception_subcode,
- mach_port_t crashing_thread) {
- Breakpad *breakpad = (Breakpad *)context;
+bool Breakpad::ExceptionHandlerDirectCallback(void* context,
+ int exception_type,
+ int exception_code,
+ int exception_subcode,
+ mach_port_t crashing_thread) {
+ Breakpad* breakpad = (Breakpad*)context;
// If our context is damaged or something, just return false to indicate that
// the handler should continue without us.
@@ -280,11 +280,11 @@
}
//=============================================================================
-bool Breakpad::HandleMinidumpCallback(const char *dump_dir,
- const char *minidump_id,
- void *context,
+bool Breakpad::HandleMinidumpCallback(const char* dump_dir,
+ const char* minidump_id,
+ void* context,
bool succeeded) {
- Breakpad *breakpad = (Breakpad *)context;
+ Breakpad* breakpad = (Breakpad*)context;
// If our context is damaged or something, just return false to indicate that
// the handler should continue without us.
@@ -307,9 +307,9 @@
// simple non-static C name
//
extern "C" {
-NSString * GetResourcePath();
-NSString * GetResourcePath() {
- NSString *resourcePath = nil;
+NSString* GetResourcePath();
+NSString* GetResourcePath() {
+ NSString* resourcePath = nil;
// If there are multiple breakpads installed then calling bundleWithIdentifier
// will not work properly, so only use that as a backup plan.
@@ -320,17 +320,17 @@
// Get the pathname to the code which contains this function
Dl_info info;
if (dladdr((const void*)GetResourcePath, &info) != 0) {
- NSFileManager *filemgr = [NSFileManager defaultManager];
- NSString *filePath =
+ NSFileManager* filemgr = [NSFileManager defaultManager];
+ NSString* filePath =
[filemgr stringWithFileSystemRepresentation:info.dli_fname
length:strlen(info.dli_fname)];
- NSString *bundlePath = [filePath stringByDeletingLastPathComponent];
+ NSString* bundlePath = [filePath stringByDeletingLastPathComponent];
// The "Resources" directory should be in the same directory as the
// executable code, since that's how the Breakpad framework is built.
resourcePath = [bundlePath stringByAppendingPathComponent:@"Resources/"];
} else {
// fallback plan
- NSBundle *bundle =
+ NSBundle* bundle =
[NSBundle bundleWithIdentifier:@"com.Google.BreakpadFramework"];
resourcePath = [bundle resourcePath];
}
@@ -340,7 +340,7 @@
} // extern "C"
//=============================================================================
-bool Breakpad::Initialize(NSDictionary *parameters) {
+bool Breakpad::Initialize(NSDictionary* parameters) {
// Initialize
config_params_ = NULL;
handler_ = NULL;
@@ -375,7 +375,7 @@
//=============================================================================
bool Breakpad::InitializeOutOfProcess(NSDictionary* parameters) {
// Get path to Inspector executable.
- NSString *inspectorPathString = KeyValue(@BREAKPAD_INSPECTOR_LOCATION);
+ NSString* inspectorPathString = KeyValue(@BREAKPAD_INSPECTOR_LOCATION);
// Standardize path (resolve symlinkes, etc.) and escape spaces
inspectorPathString = [inspectorPathString stringByStandardizingPath];
@@ -434,34 +434,34 @@
}
//=============================================================================
-bool Breakpad::ExtractParameters(NSDictionary *parameters) {
- NSUserDefaults *stdDefaults = [NSUserDefaults standardUserDefaults];
- NSString *skipConfirm = [stdDefaults stringForKey:@BREAKPAD_SKIP_CONFIRM];
- NSString *sendAndExit = [stdDefaults stringForKey:@BREAKPAD_SEND_AND_EXIT];
+bool Breakpad::ExtractParameters(NSDictionary* parameters) {
+ NSUserDefaults* stdDefaults = [NSUserDefaults standardUserDefaults];
+ NSString* skipConfirm = [stdDefaults stringForKey:@BREAKPAD_SKIP_CONFIRM];
+ NSString* sendAndExit = [stdDefaults stringForKey:@BREAKPAD_SEND_AND_EXIT];
- NSString *serverType = [parameters objectForKey:@BREAKPAD_SERVER_TYPE];
- NSString *display = [parameters objectForKey:@BREAKPAD_PRODUCT_DISPLAY];
- NSString *product = [parameters objectForKey:@BREAKPAD_PRODUCT];
- NSString *version = [parameters objectForKey:@BREAKPAD_VERSION];
- NSString *urlStr = [parameters objectForKey:@BREAKPAD_URL];
- NSString *interval = [parameters objectForKey:@BREAKPAD_REPORT_INTERVAL];
- NSString *inspectorPathString =
+ NSString* serverType = [parameters objectForKey:@BREAKPAD_SERVER_TYPE];
+ NSString* display = [parameters objectForKey:@BREAKPAD_PRODUCT_DISPLAY];
+ NSString* product = [parameters objectForKey:@BREAKPAD_PRODUCT];
+ NSString* version = [parameters objectForKey:@BREAKPAD_VERSION];
+ NSString* urlStr = [parameters objectForKey:@BREAKPAD_URL];
+ NSString* interval = [parameters objectForKey:@BREAKPAD_REPORT_INTERVAL];
+ NSString* inspectorPathString =
[parameters objectForKey:@BREAKPAD_INSPECTOR_LOCATION];
- NSString *reporterPathString =
+ NSString* reporterPathString =
[parameters objectForKey:@BREAKPAD_REPORTER_EXE_LOCATION];
- NSString *timeout = [parameters objectForKey:@BREAKPAD_CONFIRM_TIMEOUT];
- NSArray *logFilePaths = [parameters objectForKey:@BREAKPAD_LOGFILES];
- NSString *logFileTailSize =
+ NSString* timeout = [parameters objectForKey:@BREAKPAD_CONFIRM_TIMEOUT];
+ NSArray* logFilePaths = [parameters objectForKey:@BREAKPAD_LOGFILES];
+ NSString* logFileTailSize =
[parameters objectForKey:@BREAKPAD_LOGFILE_UPLOAD_SIZE];
- NSString *requestUserText =
+ NSString* requestUserText =
[parameters objectForKey:@BREAKPAD_REQUEST_COMMENTS];
- NSString *requestEmail = [parameters objectForKey:@BREAKPAD_REQUEST_EMAIL];
- NSString *vendor =
+ NSString* requestEmail = [parameters objectForKey:@BREAKPAD_REQUEST_EMAIL];
+ NSString* vendor =
[parameters objectForKey:@BREAKPAD_VENDOR];
- NSString *dumpSubdirectory =
+ NSString* dumpSubdirectory =
[parameters objectForKey:@BREAKPAD_DUMP_DIRECTORY];
- NSDictionary *serverParameters =
+ NSDictionary* serverParameters =
[parameters objectForKey:@BREAKPAD_SERVER_PARAMETER_DICT];
// These may have been set above as user prefs, which take priority.
@@ -536,7 +536,7 @@
}
// Find the helper applications if not specified in user config.
- NSString *resourcePath = nil;
+ NSString* resourcePath = nil;
if (!inspectorPathString || !reporterPathString) {
resourcePath = GetResourcePath();
if (!resourcePath) {
@@ -591,7 +591,7 @@
new (gKeyValueAllocator->Allocate(sizeof(SimpleStringDictionary)) )
SimpleStringDictionary();
- SimpleStringDictionary &dictionary = *config_params_;
+ SimpleStringDictionary& dictionary = *config_params_;
dictionary.SetKeyValue(BREAKPAD_SERVER_TYPE, [serverType UTF8String]);
dictionary.SetKeyValue(BREAKPAD_PRODUCT_DISPLAY, [display UTF8String]);
@@ -633,8 +633,8 @@
if (serverParameters) {
// For each key-value pair, call BreakpadAddUploadParameter()
- NSEnumerator *keyEnumerator = [serverParameters keyEnumerator];
- NSString *aParameter;
+ NSEnumerator* keyEnumerator = [serverParameters keyEnumerator];
+ NSString* aParameter;
while ((aParameter = [keyEnumerator nextObject])) {
BreakpadAddUploadParameter(this, aParameter,
[serverParameters objectForKey:aParameter]);
@@ -644,7 +644,7 @@
}
//=============================================================================
-void Breakpad::SetKeyValue(NSString *key, NSString *value) {
+void Breakpad::SetKeyValue(NSString* key, NSString* value) {
// We allow nil values. This is the same as removing the keyvalue.
if (!config_params_ || !key)
return;
@@ -653,16 +653,16 @@
}
//=============================================================================
-NSString *Breakpad::KeyValue(NSString *key) {
+NSString* Breakpad::KeyValue(NSString* key) {
if (!config_params_ || !key)
return nil;
- const char *value = config_params_->GetValueForKey([key UTF8String]);
+ const char* value = config_params_->GetValueForKey([key UTF8String]);
return value ? [NSString stringWithUTF8String:value] : nil;
}
//=============================================================================
-void Breakpad::RemoveKeyValue(NSString *key) {
+void Breakpad::RemoveKeyValue(NSString* key) {
if (!config_params_ || !key) return;
config_params_->RemoveKey([key UTF8String]);
@@ -722,7 +722,7 @@
if (result == KERN_SUCCESS) {
// Now, send a series of key-value pairs to the Inspector.
- const SimpleStringDictionary::Entry *entry = NULL;
+ const SimpleStringDictionary::Entry* entry = NULL;
SimpleStringDictionary::Iterator iter(*config_params_);
while ( (entry = iter.Next()) ) {
@@ -759,7 +759,7 @@
}
//=============================================================================
-bool Breakpad::HandleMinidump(const char *dump_dir, const char *minidump_id) {
+bool Breakpad::HandleMinidump(const char* dump_dir, const char* minidump_id) {
google_breakpad::ConfigFile config_file;
config_file.WriteFile(dump_dir, config_params_, dump_dir, minidump_id);
google_breakpad::LaunchReporter(
@@ -775,7 +775,7 @@
#pragma mark Public API
//=============================================================================
-BreakpadRef BreakpadCreate(NSDictionary *parameters) {
+BreakpadRef BreakpadCreate(NSDictionary* parameters) {
try {
// This is confusing. Our two main allocators for breakpad memory are:
// - gKeyValueAllocator for the key/value memory
@@ -815,8 +815,8 @@
ProtectedMemoryAllocator(breakpad_pool_size);
// Stack-based autorelease pool for Breakpad::Create() obj-c code.
- NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
- Breakpad *breakpad = Breakpad::Create(parameters);
+ NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+ Breakpad* breakpad = Breakpad::Create(parameters);
if (breakpad) {
// Make read-only to protect against memory smashers
@@ -856,7 +856,7 @@
//=============================================================================
void BreakpadRelease(BreakpadRef ref) {
try {
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (gMasterAllocator) {
gMasterAllocator->Unprotect();
@@ -889,10 +889,10 @@
}
//=============================================================================
-void BreakpadSetKeyValue(BreakpadRef ref, NSString *key, NSString *value) {
+void BreakpadSetKeyValue(BreakpadRef ref, NSString* key, NSString* value) {
try {
// Not called at exception time
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (breakpad && key && gKeyValueAllocator) {
ProtectedMemoryLocker locker(&gDictionaryMutex, gKeyValueAllocator);
@@ -905,20 +905,20 @@
}
void BreakpadAddUploadParameter(BreakpadRef ref,
- NSString *key,
- NSString *value) {
+ NSString* key,
+ NSString* value) {
// The only difference, internally, between an upload parameter and
// a key value one that is set with BreakpadSetKeyValue is that we
// prepend the keyname with a special prefix. This informs the
// crash sender that the parameter should be sent along with the
// POST of the crash dump upload.
try {
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (breakpad && key && gKeyValueAllocator) {
ProtectedMemoryLocker locker(&gDictionaryMutex, gKeyValueAllocator);
- NSString *prefixedKey = [@BREAKPAD_SERVER_PARAMETER_PREFIX
+ NSString* prefixedKey = [@BREAKPAD_SERVER_PARAMETER_PREFIX
stringByAppendingString:key];
breakpad->SetKeyValue(prefixedKey, value);
}
@@ -928,15 +928,15 @@
}
void BreakpadRemoveUploadParameter(BreakpadRef ref,
- NSString *key) {
+ NSString* key) {
try {
// Not called at exception time
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (breakpad && key && gKeyValueAllocator) {
ProtectedMemoryLocker locker(&gDictionaryMutex, gKeyValueAllocator);
- NSString *prefixedKey = [NSString stringWithFormat:@"%@%@",
+ NSString* prefixedKey = [NSString stringWithFormat:@"%@%@",
@BREAKPAD_SERVER_PARAMETER_PREFIX, key];
breakpad->RemoveKeyValue(prefixedKey);
}
@@ -945,12 +945,12 @@
}
}
//=============================================================================
-NSString *BreakpadKeyValue(BreakpadRef ref, NSString *key) {
- NSString *value = nil;
+NSString* BreakpadKeyValue(BreakpadRef ref, NSString* key) {
+ NSString* value = nil;
try {
// Not called at exception time
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (!breakpad || !key || !gKeyValueAllocator)
return nil;
@@ -966,10 +966,10 @@
}
//=============================================================================
-void BreakpadRemoveKeyValue(BreakpadRef ref, NSString *key) {
+void BreakpadRemoveKeyValue(BreakpadRef ref, NSString* key) {
try {
// Not called at exception time
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (breakpad && key && gKeyValueAllocator) {
ProtectedMemoryLocker locker(&gDictionaryMutex, gKeyValueAllocator);
@@ -984,7 +984,7 @@
//=============================================================================
void BreakpadGenerateAndSendReport(BreakpadRef ref) {
try {
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (breakpad && gKeyValueAllocator) {
ProtectedMemoryLocker locker(&gDictionaryMutex, gKeyValueAllocator);
@@ -1001,10 +1001,10 @@
//=============================================================================
void BreakpadSetFilterCallback(BreakpadRef ref,
BreakpadFilterCallback callback,
- void *context) {
+ void* context) {
try {
- Breakpad *breakpad = (Breakpad *)ref;
+ Breakpad* breakpad = (Breakpad*)ref;
if (breakpad && gBreakpadAllocator) {
// share the dictionary mutex here (we really don't need a mutex)
@@ -1018,14 +1018,14 @@
}
//============================================================================
-void BreakpadAddLogFile(BreakpadRef ref, NSString *logPathname) {
+void BreakpadAddLogFile(BreakpadRef ref, NSString* logPathname) {
int logFileCounter = 0;
- NSString *logFileKey = [NSString stringWithFormat:@"%@%d",
+ NSString* logFileKey = [NSString stringWithFormat:@"%@%d",
@BREAKPAD_LOGFILE_KEY_PREFIX,
logFileCounter];
- NSString *existingLogFilename = nil;
+ NSString* existingLogFilename = nil;
existingLogFilename = BreakpadKeyValue(ref, logFileKey);
// Find the first log file key that we can use by testing for existence
while (existingLogFilename) {
diff --git a/src/client/mac/Framework/OnDemandServer.h b/src/client/mac/Framework/OnDemandServer.h
index d4db5d3..be0d2b7 100644
--- a/src/client/mac/Framework/OnDemandServer.h
+++ b/src/client/mac/Framework/OnDemandServer.h
@@ -41,7 +41,7 @@
// Example Usage :
//
// kern_return_t result;
-// OnDemandServer *server = OnDemandServer::Create("/tmp/myserver",
+// OnDemandServer* server = OnDemandServer::Create("/tmp/myserver",
// "com.MyCompany.MyServiceName",
// true,
// &result);
@@ -88,8 +88,8 @@
}
// Creates the bootstrap server and service
- kern_return_t Initialize(const char *server_command,
- const char *service_name,
+ kern_return_t Initialize(const char* server_command,
+ const char* service_name,
bool unregister_on_cleanup);
// Returns an OnDemandServer object if successful, or NULL if there's
@@ -110,10 +110,10 @@
// out_result : if non-NULL, returns the result
// this value will be KERN_SUCCESS if Create() returns non-NULL
//
- static OnDemandServer *Create(const char *server_command,
- const char *service_name,
+ static OnDemandServer* Create(const char *server_command,
+ const char* service_name,
bool unregister_on_cleanup,
- kern_return_t *out_result);
+ kern_return_t* out_result);
// Cleans up and if LaunchOnDemand() has not yet been called then
// the bootstrap service will be unregistered.
diff --git a/src/client/mac/Framework/OnDemandServer.mm b/src/client/mac/Framework/OnDemandServer.mm
index a2ffa43..b6b59ca 100644
--- a/src/client/mac/Framework/OnDemandServer.mm
+++ b/src/client/mac/Framework/OnDemandServer.mm
@@ -49,11 +49,11 @@
#endif
//==============================================================================
-OnDemandServer *OnDemandServer::Create(const char *server_command,
- const char *service_name,
+OnDemandServer* OnDemandServer::Create(const char* server_command,
+ const char* service_name,
bool unregister_on_cleanup,
- kern_return_t *out_result) {
- OnDemandServer *server = new OnDemandServer();
+ kern_return_t* out_result) {
+ OnDemandServer* server = new OnDemandServer();
if (!server) return NULL;
@@ -74,8 +74,8 @@
}
//==============================================================================
-kern_return_t OnDemandServer::Initialize(const char *server_command,
- const char *service_name,
+kern_return_t OnDemandServer::Initialize(const char* server_command,
+ const char* service_name,
bool unregister_on_cleanup) {
unregister_on_cleanup_ = unregister_on_cleanup;
diff --git a/src/client/mac/crash_generation/ConfigFile.h b/src/client/mac/crash_generation/ConfigFile.h
index f2da7c2..11bc2e4 100644
--- a/src/client/mac/crash_generation/ConfigFile.h
+++ b/src/client/mac/crash_generation/ConfigFile.h
@@ -35,7 +35,7 @@
namespace google_breakpad {
-BOOL EnsureDirectoryPathExists(NSString *dirPath);
+BOOL EnsureDirectoryPathExists(NSString* dirPath);
//=============================================================================
class ConfigFile {
@@ -50,11 +50,11 @@
}
void WriteFile(const char* directory,
- const SimpleStringDictionary *configurationParameters,
- const char *dump_dir,
- const char *minidump_id);
+ const SimpleStringDictionary* configurationParameters,
+ const char* dump_dir,
+ const char* minidump_id);
- const char *GetFilePath() { return config_file_path_; }
+ const char* GetFilePath() { return config_file_path_; }
void Unlink() {
if (config_file_ != -1)
@@ -64,16 +64,16 @@
}
private:
- BOOL WriteData(const void *data, size_t length);
+ BOOL WriteData(const void* data, size_t length);
- BOOL AppendConfigData(const char *key,
- const void *data,
+ BOOL AppendConfigData(const char* key,
+ const void* data,
size_t length);
- BOOL AppendConfigString(const char *key,
- const char *value);
+ BOOL AppendConfigString(const char* key,
+ const char* value);
- BOOL AppendCrashTimeParameters(const char *processStartTimeString);
+ BOOL AppendCrashTimeParameters(const char* processStartTimeString);
int config_file_; // descriptor for config file
char config_file_path_[PATH_MAX]; // Path to configuration file
diff --git a/src/client/mac/crash_generation/ConfigFile.mm b/src/client/mac/crash_generation/ConfigFile.mm
index acab7de..57d0759 100644
--- a/src/client/mac/crash_generation/ConfigFile.mm
+++ b/src/client/mac/crash_generation/ConfigFile.mm
@@ -42,10 +42,10 @@
namespace google_breakpad {
//=============================================================================
-BOOL EnsureDirectoryPathExists(NSString *dirPath) {
- NSFileManager *mgr = [NSFileManager defaultManager];
+BOOL EnsureDirectoryPathExists(NSString* dirPath) {
+ NSFileManager* mgr = [NSFileManager defaultManager];
- NSDictionary *attrs =
+ NSDictionary* attrs =
[NSDictionary dictionaryWithObject:[NSNumber numberWithUnsignedLong:0750]
forKey:NSFilePosixPermissions];
@@ -56,15 +56,15 @@
}
//=============================================================================
-BOOL ConfigFile::WriteData(const void *data, size_t length) {
+BOOL ConfigFile::WriteData(const void* data, size_t length) {
size_t result = write(config_file_, data, length);
return result == length;
}
//=============================================================================
-BOOL ConfigFile::AppendConfigData(const char *key,
- const void *data, size_t length) {
+BOOL ConfigFile::AppendConfigData(const char* key,
+ const void* data, size_t length) {
assert(config_file_ != -1);
if (!key) {
@@ -88,13 +88,13 @@
}
//=============================================================================
-BOOL ConfigFile::AppendConfigString(const char *key,
- const char *value) {
+BOOL ConfigFile::AppendConfigString(const char* key,
+ const char* value) {
return AppendConfigData(key, value, strlen(value));
}
//=============================================================================
-BOOL ConfigFile::AppendCrashTimeParameters(const char *processStartTimeString) {
+BOOL ConfigFile::AppendCrashTimeParameters(const char* processStartTimeString) {
// Set process uptime parameter
struct timeval tv;
gettimeofday(&tv, NULL);
@@ -118,9 +118,9 @@
//=============================================================================
void ConfigFile::WriteFile(const char* directory,
- const SimpleStringDictionary *configurationParameters,
- const char *dump_dir,
- const char *minidump_id) {
+ const SimpleStringDictionary* configurationParameters,
+ const char* dump_dir,
+ const char* minidump_id) {
assert(config_file_ == -1);
@@ -146,9 +146,9 @@
// Write out the configuration parameters
BOOL result = YES;
- const SimpleStringDictionary &dictionary = *configurationParameters;
+ const SimpleStringDictionary& dictionary = *configurationParameters;
- const SimpleStringDictionary::Entry *entry = NULL;
+ const SimpleStringDictionary::Entry* entry = NULL;
SimpleStringDictionary::Iterator iter(dictionary);
while ((entry = iter.Next())) {
diff --git a/src/client/mac/crash_generation/Inspector.h b/src/client/mac/crash_generation/Inspector.h
index 7f923ed..c967113 100644
--- a/src/client/mac/crash_generation/Inspector.h
+++ b/src/client/mac/crash_generation/Inspector.h
@@ -63,7 +63,7 @@
public:
KeyValueMessageData() {}
explicit KeyValueMessageData(
- const google_breakpad::SimpleStringDictionary::Entry &inEntry) {
+ const google_breakpad::SimpleStringDictionary::Entry& inEntry) {
strlcpy(key, inEntry.key, sizeof(key) );
strlcpy(value, inEntry.value, sizeof(value) );
}
@@ -80,7 +80,7 @@
//=============================================================================
class MinidumpLocation {
public:
- MinidumpLocation(NSString *minidumpDir) {
+ MinidumpLocation(NSString* minidumpDir) {
// Ensure that the path exists. Fallback to /tmp if unable to locate path.
assert(minidumpDir);
if (!EnsureDirectoryPathExists(minidumpDir)) {
@@ -100,8 +100,8 @@
strlcpy(minidump_id_, next_minidump_id.c_str(), sizeof(minidump_id_));
}
- const char *GetPath() { return minidump_dir_path_; }
- const char *GetID() { return minidump_id_; }
+ const char* GetPath() { return minidump_dir_path_; }
+ const char* GetID() { return minidump_id_; }
private:
char minidump_dir_path_[PATH_MAX]; // Path to minidump directory
@@ -116,7 +116,7 @@
// given a bootstrap service name, receives mach messages
// from a crashed process, then inspects it, creates a minidump file
// and asks the user if he wants to upload it to a server.
- void Inspect(const char *receive_port_name);
+ void Inspect(const char* receive_port_name);
private:
// The Inspector is invoked with its bootstrap port set to the bootstrap
@@ -131,8 +131,8 @@
// ServiceCheckOut.
kern_return_t ResetBootstrapPort();
- kern_return_t ServiceCheckIn(const char *receive_port_name);
- kern_return_t ServiceCheckOut(const char *receive_port_name);
+ kern_return_t ServiceCheckIn(const char* receive_port_name);
+ kern_return_t ServiceCheckOut(const char* receive_port_name);
kern_return_t ReadMessages();
diff --git a/src/client/mac/crash_generation/Inspector.mm b/src/client/mac/crash_generation/Inspector.mm
index dc6f480..d5fc29e 100644
--- a/src/client/mac/crash_generation/Inspector.mm
+++ b/src/client/mac/crash_generation/Inspector.mm
@@ -52,7 +52,7 @@
namespace google_breakpad {
//=============================================================================
-void Inspector::Inspect(const char *receive_port_name) {
+void Inspector::Inspect(const char* receive_port_name) {
kern_return_t result = ResetBootstrapPort();
if (result != KERN_SUCCESS) {
return;
@@ -143,7 +143,7 @@
}
//=============================================================================
-kern_return_t Inspector::ServiceCheckIn(const char *receive_port_name) {
+kern_return_t Inspector::ServiceCheckIn(const char* receive_port_name) {
// We need to get the mach port representing this service, so we can
// get information from the crashed process.
kern_return_t kr = bootstrap_check_in(bootstrap_subset_port_,
@@ -160,7 +160,7 @@
}
//=============================================================================
-kern_return_t Inspector::ServiceCheckOut(const char *receive_port_name) {
+kern_return_t Inspector::ServiceCheckOut(const char* receive_port_name) {
// We're done receiving mach messages from the crashed process,
// so clean up a bit.
kern_return_t kr;
@@ -198,7 +198,7 @@
kern_return_t result = receive_port.WaitForMessage(&message, 1000);
if (result == KERN_SUCCESS) {
- InspectorInfo &info = (InspectorInfo &)*message.GetData();
+ InspectorInfo& info = (InspectorInfo&)*message.GetData();
exception_type_ = info.exception_type;
exception_code_ = info.exception_code;
exception_subcode_ = info.exception_subcode;
@@ -237,7 +237,7 @@
result = receive_port.WaitForMessage(¶meter_message, 1000);
if(result == KERN_SUCCESS) {
- KeyValueMessageData &key_value_data =
+ KeyValueMessageData& key_value_data =
(KeyValueMessageData&)*parameter_message.GetData();
// If we get a blank key, make sure we don't increment the
// parameter count; in some cases (notably on-demand generation
@@ -267,27 +267,27 @@
// keep the task quiet while we're looking at it
task_suspend(remote_task_);
- NSString *minidumpDir;
+ NSString* minidumpDir;
- const char *minidumpDirectory =
+ const char* minidumpDirectory =
config_params_.GetValueForKey(BREAKPAD_DUMP_DIRECTORY);
// If the client app has not specified a minidump directory,
// use a default of Library/<kDefaultLibrarySubdirectory>/<Product Name>
if (!minidumpDirectory || 0 == strlen(minidumpDirectory)) {
- NSArray *libraryDirectories =
+ NSArray* libraryDirectories =
NSSearchPathForDirectoriesInDomains(NSLibraryDirectory,
NSUserDomainMask,
YES);
- NSString *applicationSupportDirectory =
+ NSString* applicationSupportDirectory =
[libraryDirectories objectAtIndex:0];
- NSString *library_subdirectory = [NSString
+ NSString* library_subdirectory = [NSString
stringWithUTF8String:kDefaultLibrarySubdirectory];
- NSString *breakpad_product = [NSString
+ NSString* breakpad_product = [NSString
stringWithUTF8String:config_params_.GetValueForKey(BREAKPAD_PRODUCT)];
- NSArray *path_components = [NSArray
+ NSArray* path_components = [NSArray
arrayWithObjects:applicationSupportDirectory,
library_subdirectory,
breakpad_product,
@@ -306,11 +306,11 @@
// assumes system encoding and in RTL locales will prepend an LTR override
// character for paths beginning with '/' which fileSystemRepresentation does
// not remove. Filed as rdar://6889706 .
- NSString *path_ns = [NSString
+ NSString* path_ns = [NSString
stringWithUTF8String:minidumpLocation.GetPath()];
- NSString *pathid_ns = [NSString
+ NSString* pathid_ns = [NSString
stringWithUTF8String:minidumpLocation.GetID()];
- NSString *minidumpPath = [path_ns stringByAppendingPathComponent:pathid_ns];
+ NSString* minidumpPath = [path_ns stringByAppendingPathComponent:pathid_ns];
minidumpPath = [minidumpPath
stringByAppendingPathExtension:@"dmp"];
diff --git a/src/client/mac/crash_generation/crash_generation_server.cc b/src/client/mac/crash_generation/crash_generation_server.cc
index 451e8d9..ae44e8b 100644
--- a/src/client/mac/crash_generation/crash_generation_server.cc
+++ b/src/client/mac/crash_generation/crash_generation_server.cc
@@ -38,15 +38,15 @@
namespace google_breakpad {
CrashGenerationServer::CrashGenerationServer(
- const char *mach_port_name,
+ const char* mach_port_name,
FilterCallback filter,
- void *filter_context,
+ void* filter_context,
OnClientDumpRequestCallback dump_callback,
- void *dump_context,
+ void* dump_context,
OnClientExitingCallback exit_callback,
- void *exit_context,
+ void* exit_context,
bool generate_dumps,
- const std::string &dump_path)
+ const std::string& dump_path)
: filter_(filter),
filter_context_(filter_context),
dump_callback_(dump_callback),
@@ -90,8 +90,8 @@
}
// static
-void *CrashGenerationServer::WaitForMessages(void *server) {
- CrashGenerationServer *self =
+void* CrashGenerationServer::WaitForMessages(void* server) {
+ CrashGenerationServer* self =
reinterpret_cast<CrashGenerationServer*>(server);
while (self->WaitForOneMessage()) {}
return NULL;
@@ -104,7 +104,7 @@
if (result == KERN_SUCCESS) {
switch (message.GetMessageID()) {
case kDumpRequestMessage: {
- ExceptionInfo &info = (ExceptionInfo &)*message.GetData();
+ ExceptionInfo& info = (ExceptionInfo&)*message.GetData();
mach_port_t remote_task = message.GetTranslatedPort(0);
mach_port_t crashing_thread = message.GetTranslatedPort(1);
diff --git a/src/client/mac/crash_generation/crash_generation_server.h b/src/client/mac/crash_generation/crash_generation_server.h
index 85bd5b5..82fef14 100644
--- a/src/client/mac/crash_generation/crash_generation_server.h
+++ b/src/client/mac/crash_generation/crash_generation_server.h
@@ -59,14 +59,14 @@
// WARNING: callbacks may be invoked on a different thread
// than that which creates the CrashGenerationServer. They must
// be thread safe.
- typedef void (*OnClientDumpRequestCallback)(void *context,
- const ClientInfo &client_info,
- const std::string &file_path);
+ typedef void (*OnClientDumpRequestCallback)(void* context,
+ const ClientInfo& client_info,
+ const std::string& file_path);
- typedef void (*OnClientExitingCallback)(void *context,
- const ClientInfo &client_info);
+ typedef void (*OnClientExitingCallback)(void* context,
+ const ClientInfo& client_info);
// If a FilterCallback returns false, the dump will not be written.
- typedef bool (*FilterCallback)(void *context);
+ typedef bool (*FilterCallback)(void* context);
// Create an instance with the given parameters.
//
@@ -83,15 +83,15 @@
// passed for this parameter.
// dump_path: Path for generating dumps; required only if true is
// passed for generateDumps parameter; NULL can be passed otherwise.
- CrashGenerationServer(const char *mach_port_name,
+ CrashGenerationServer(const char* mach_port_name,
FilterCallback filter,
- void *filter_context,
+ void* filter_context,
OnClientDumpRequestCallback dump_callback,
- void *dump_context,
+ void* dump_context,
OnClientExitingCallback exit_callback,
- void *exit_context,
+ void* exit_context,
bool generate_dumps,
- const std::string &dump_path);
+ const std::string& dump_path);
~CrashGenerationServer();
@@ -105,24 +105,24 @@
private:
// Return a unique filename at which a minidump can be written.
- bool MakeMinidumpFilename(std::string &outFilename);
+ bool MakeMinidumpFilename(std::string& outFilename);
// Loop reading client messages and responding to them until
// a quit message is received.
- static void *WaitForMessages(void *server);
+ static void* WaitForMessages(void* server);
// Wait for a single client message and respond to it. Returns false
// if a quit message was received or if an error occurred.
bool WaitForOneMessage();
FilterCallback filter_;
- void *filter_context_;
+ void* filter_context_;
OnClientDumpRequestCallback dump_callback_;
- void *dump_context_;
+ void* dump_context_;
OnClientExitingCallback exit_callback_;
- void *exit_context_;
+ void* exit_context_;
bool generate_dumps_;
diff --git a/src/client/mac/handler/breakpad_nlist_64.cc b/src/client/mac/handler/breakpad_nlist_64.cc
index 3492b82..b4f04c9 100644
--- a/src/client/mac/handler/breakpad_nlist_64.cc
+++ b/src/client/mac/handler/breakpad_nlist_64.cc
@@ -131,7 +131,7 @@
template<typename nlist_type>
int
-__breakpad_fdnlist(int fd, nlist_type *list, const char **symbolNames,
+__breakpad_fdnlist(int fd, nlist_type* list, const char** symbolNames,
cpu_type_t cpu_type);
/*
@@ -139,9 +139,9 @@
*/
template <typename nlist_type>
-int breakpad_nlist_common(const char *name,
- nlist_type *list,
- const char **symbolNames,
+int breakpad_nlist_common(const char* name,
+ nlist_type* list,
+ const char** symbolNames,
cpu_type_t cpu_type) {
int fd = open(name, O_RDONLY, 0);
if (fd < 0)
@@ -151,16 +151,16 @@
return n;
}
-int breakpad_nlist(const char *name,
- struct nlist *list,
- const char **symbolNames,
+int breakpad_nlist(const char* name,
+ struct nlist* list,
+ const char** symbolNames,
cpu_type_t cpu_type) {
return breakpad_nlist_common(name, list, symbolNames, cpu_type);
}
-int breakpad_nlist(const char *name,
- struct nlist_64 *list,
- const char **symbolNames,
+int breakpad_nlist(const char* name,
+ struct nlist_64* list,
+ const char** symbolNames,
cpu_type_t cpu_type) {
return breakpad_nlist_common(name, list, symbolNames, cpu_type);
}
@@ -168,7 +168,7 @@
/* Note: __fdnlist() is called from kvm_nlist in libkvm's kvm.c */
template<typename nlist_type>
-int __breakpad_fdnlist(int fd, nlist_type *list, const char **symbolNames,
+int __breakpad_fdnlist(int fd, nlist_type* list, const char** symbolNames,
cpu_type_t cpu_type) {
typedef typename MachBits<nlist_type>::mach_header_type mach_header_type;
typedef typename MachBits<nlist_type>::word_type word_type;
@@ -189,9 +189,9 @@
}
struct exec buf;
- if (read(fd, (char *)&buf, sizeof(buf)) != sizeof(buf) ||
- (N_BADMAG(buf) && *((uint32_t *)&buf) != magic &&
- CFSwapInt32BigToHost(*((uint32_t *)&buf)) != FAT_MAGIC &&
+ if (read(fd, (char*)&buf, sizeof(buf)) != sizeof(buf) ||
+ (N_BADMAG(buf) && *((uint32_t*)&buf) != magic &&
+ CFSwapInt32BigToHost(*((uint32_t*)&buf)) != FAT_MAGIC &&
/* The following is the big-endian ppc64 check */
(*((uint32_t*)&buf)) != FAT_MAGIC)) {
return -1;
@@ -199,15 +199,15 @@
/* Deal with fat file if necessary */
unsigned arch_offset = 0;
- if (CFSwapInt32BigToHost(*((uint32_t *)&buf)) == FAT_MAGIC ||
+ if (CFSwapInt32BigToHost(*((uint32_t*)&buf)) == FAT_MAGIC ||
/* The following is the big-endian ppc64 check */
- *((unsigned int *)&buf) == FAT_MAGIC) {
+ *((unsigned int*)&buf) == FAT_MAGIC) {
/* Read in the fat header */
struct fat_header fh;
if (lseek(fd, 0, SEEK_SET) == -1) {
return -1;
}
- if (read(fd, (char *)&fh, sizeof(fh)) != sizeof(fh)) {
+ if (read(fd, (char*)&fh, sizeof(fh)) != sizeof(fh)) {
return -1;
}
@@ -215,12 +215,12 @@
fh.nfat_arch = CFSwapInt32BigToHost(fh.nfat_arch);
/* Read in the fat archs */
- struct fat_arch *fat_archs =
- (struct fat_arch *)malloc(fh.nfat_arch * sizeof(struct fat_arch));
+ struct fat_arch* fat_archs =
+ (struct fat_arch*)malloc(fh.nfat_arch * sizeof(struct fat_arch));
if (fat_archs == NULL) {
return -1;
}
- if (read(fd, (char *)fat_archs,
+ if (read(fd, (char*)fat_archs,
sizeof(struct fat_arch) * fh.nfat_arch) !=
(ssize_t)(sizeof(struct fat_arch) * fh.nfat_arch)) {
free(fat_archs);
@@ -244,7 +244,7 @@
CFSwapInt32BigToHost(fat_archs[i].align);
}
- struct fat_arch *fap = NULL;
+ struct fat_arch* fap = NULL;
for (unsigned i = 0; i < fh.nfat_arch; i++) {
if (fat_archs[i].cputype == cpu_type) {
fap = &fat_archs[i];
@@ -263,7 +263,7 @@
if (lseek(fd, arch_offset, SEEK_SET) == -1) {
return -1;
}
- if (read(fd, (char *)&buf, sizeof(buf)) != sizeof(buf)) {
+ if (read(fd, (char*)&buf, sizeof(buf)) != sizeof(buf)) {
return -1;
}
}
@@ -271,48 +271,45 @@
off_t sa; /* symbol address */
off_t ss; /* start of strings */
register_t n;
- if (*((unsigned int *)&buf) == magic) {
+ if (*((unsigned int*)&buf) == magic) {
if (lseek(fd, arch_offset, SEEK_SET) == -1) {
return -1;
}
mach_header_type mh;
- if (read(fd, (char *)&mh, sizeof(mh)) != sizeof(mh)) {
+ if (read(fd, (char*)&mh, sizeof(mh)) != sizeof(mh)) {
return -1;
}
- struct load_command *load_commands =
- (struct load_command *)malloc(mh.sizeofcmds);
+ struct load_command* load_commands =
+ (struct load_command*)malloc(mh.sizeofcmds);
if (load_commands == NULL) {
return -1;
}
- if (read(fd, (char *)load_commands, mh.sizeofcmds) !=
+ if (read(fd, (char*)load_commands, mh.sizeofcmds) !=
(ssize_t)mh.sizeofcmds) {
free(load_commands);
return -1;
}
- struct symtab_command *stp = NULL;
- struct load_command *lcp = load_commands;
+ struct symtab_command* stp = NULL;
+ struct load_command* lcp = load_commands;
// iterate through all load commands, looking for
// LC_SYMTAB load command
for (uint32_t i = 0; i < mh.ncmds; i++) {
if (lcp->cmdsize % sizeof(word_type) != 0 ||
lcp->cmdsize <= 0 ||
- (char *)lcp + lcp->cmdsize >
- (char *)load_commands + mh.sizeofcmds) {
+ (char*)lcp + lcp->cmdsize > (char*)load_commands + mh.sizeofcmds) {
free(load_commands);
return -1;
}
if (lcp->cmd == LC_SYMTAB) {
- if (lcp->cmdsize !=
- sizeof(struct symtab_command)) {
+ if (lcp->cmdsize != sizeof(struct symtab_command)) {
free(load_commands);
return -1;
}
- stp = (struct symtab_command *)lcp;
+ stp = (struct symtab_command*)lcp;
break;
}
- lcp = (struct load_command *)
- ((char *)lcp + lcp->cmdsize);
+ lcp = (struct load_command*)((char*)lcp + lcp->cmdsize);
}
if (stp == NULL) {
free(load_commands);
@@ -347,7 +344,7 @@
if (n < m)
m = n;
- if (read(fd, (char *)space, m) != m)
+ if (read(fd, (char*)space, m) != m)
break;
n -= m;
off_t savpos = lseek(fd, 0, SEEK_CUR);
@@ -368,13 +365,13 @@
if (read(fd, nambuf, maxlen+1) == -1) {
return -1;
}
- const char *s2 = nambuf;
- for (nlist_type *p = list;
+ const char* s2 = nambuf;
+ for (nlist_type* p = list;
symbolNames[p-list] && symbolNames[p-list][0];
p++) {
// get the symbol name the user has passed in that
// corresponds to the nlist entry that we're looking at
- const char *s1 = symbolNames[p - list];
+ const char* s1 = symbolNames[p - list];
while (*s1) {
if (*s1++ != *s2++)
goto cont;
diff --git a/src/client/mac/handler/breakpad_nlist_64.h b/src/client/mac/handler/breakpad_nlist_64.h
index e8e2e08..a1a3e83 100644
--- a/src/client/mac/handler/breakpad_nlist_64.h
+++ b/src/client/mac/handler/breakpad_nlist_64.h
@@ -36,13 +36,13 @@
#include <mach/machine.h>
-int breakpad_nlist(const char *name,
- struct nlist *list,
- const char **symbolNames,
+int breakpad_nlist(const char* name,
+ struct nlist* list,
+ const char** symbolNames,
cpu_type_t cpu_type);
-int breakpad_nlist(const char *name,
- struct nlist_64 *list,
- const char **symbolNames,
+int breakpad_nlist(const char* name,
+ struct nlist_64* list,
+ const char** symbolNames,
cpu_type_t cpu_type);
#endif /* CLIENT_MAC_HANDLER_BREAKPAD_NLIST_H__ */
diff --git a/src/client/mac/handler/dynamic_images.cc b/src/client/mac/handler/dynamic_images.cc
index cdba6df..b78c208 100644
--- a/src/client/mac/handler/dynamic_images.cc
+++ b/src/client/mac/handler/dynamic_images.cc
@@ -66,7 +66,7 @@
mach_vm_size_t all_image_info_size;
};
typedef struct task_dyld_info task_dyld_info_data_t;
-typedef struct task_dyld_info *task_dyld_info_t;
+typedef struct task_dyld_info* task_dyld_info_t;
#define TASK_DYLD_INFO_COUNT (sizeof(task_dyld_info_data_t) / sizeof(natural_t))
#endif
@@ -88,7 +88,7 @@
//
static mach_vm_size_t GetMemoryRegionSize(task_port_t target_task,
const uint64_t address,
- mach_vm_size_t *size_to_end) {
+ mach_vm_size_t* size_to_end) {
mach_vm_address_t region_base = (mach_vm_address_t)address;
mach_vm_size_t region_size;
natural_t nesting_level = 0;
@@ -182,7 +182,7 @@
kern_return_t ReadTaskMemory(task_port_t target_task,
const uint64_t address,
size_t length,
- vector<uint8_t> &bytes) {
+ vector<uint8_t>& bytes) {
int systemPageSize = getpagesize();
// use the negative of the page size for the mask to find the page address
@@ -250,16 +250,16 @@
return false;
}
- const struct load_command *cmd =
- reinterpret_cast<const struct load_command *>(header + 1);
+ const struct load_command* cmd =
+ reinterpret_cast<const struct load_command*>(header + 1);
bool found_text_section = false;
bool found_dylib_id_command = false;
for (unsigned int i = 0; cmd && (i < header->ncmds); ++i) {
if (!found_text_section) {
if (cmd->cmd == MachBits::segment_load_command) {
- const mach_segment_command_type *seg =
- reinterpret_cast<const mach_segment_command_type *>(cmd);
+ const mach_segment_command_type* seg =
+ reinterpret_cast<const mach_segment_command_type*>(cmd);
if (!strcmp(seg->segname, "__TEXT")) {
image.vmaddr_ = static_cast<mach_vm_address_t>(seg->vmaddr);
@@ -277,8 +277,8 @@
if (!found_dylib_id_command) {
if (cmd->cmd == LC_ID_DYLIB) {
- const struct dylib_command *dc =
- reinterpret_cast<const struct dylib_command *>(cmd);
+ const struct dylib_command* dc =
+ reinterpret_cast<const struct dylib_command*>(cmd);
image.version_ = dc->dylib.current_version;
found_dylib_id_command = true;
@@ -289,8 +289,8 @@
return true;
}
- cmd = reinterpret_cast<const struct load_command *>
- (reinterpret_cast<const char *>(cmd) + cmd->cmdsize);
+ cmd = reinterpret_cast<const struct load_command*>
+ (reinterpret_cast<const char*>(cmd) + cmd->cmdsize);
}
return false;
@@ -349,8 +349,8 @@
typedef typename MachBits::nlist_type nlist_type;
nlist_type symbol_info[8] = {};
- const char *symbolNames[2] = { symbol_name, "\0" };
- nlist_type &list = symbol_info[0];
+ const char* symbolNames[2] = { symbol_name, "\0" };
+ nlist_type& list = symbol_info[0];
int invalidEntriesCount = breakpad_nlist(filename,
&list,
symbolNames,
@@ -396,8 +396,8 @@
return (uint64_t)task_dyld_info.all_image_info_addr;
} else {
- const char *imageSymbolName = "_dyld_all_image_infos";
- const char *dyldPath = "/usr/lib/dyld";
+ const char* imageSymbolName = "_dyld_all_image_infos";
+ const char* dyldPath = "/usr/lib/dyld";
if (Is64Bit())
return LookupSymbol<MachO64>(imageSymbolName, dyldPath, cpu_type_);
@@ -428,7 +428,7 @@
dyld_all_info_bytes) != KERN_SUCCESS)
return;
- dyld_all_image_infos *dyldInfo =
+ dyld_all_image_infos* dyldInfo =
reinterpret_cast<dyld_all_image_infos*>(&dyld_all_info_bytes[0]);
// number of loaded images
@@ -443,12 +443,12 @@
dyld_info_array_bytes) != KERN_SUCCESS)
return;
- dyld_image_info *infoArray =
+ dyld_image_info* infoArray =
reinterpret_cast<dyld_image_info*>(&dyld_info_array_bytes[0]);
images.image_list_.reserve(count);
for (int i = 0; i < count; ++i) {
- dyld_image_info &info = infoArray[i];
+ dyld_image_info& info = infoArray[i];
// First read just the mach_header from the image in the task.
vector<uint8_t> mach_header_bytes;
@@ -458,7 +458,7 @@
mach_header_bytes) != KERN_SUCCESS)
continue; // bail on this dynamic image
- mach_header_type *header =
+ mach_header_type* header =
reinterpret_cast<mach_header_type*>(&mach_header_bytes[0]);
// Now determine the total amount necessary to read the header
@@ -482,7 +482,7 @@
}
// Create an object representing this image and add it to our list.
- DynamicImage *new_image;
+ DynamicImage* new_image;
new_image = new DynamicImage(&mach_header_bytes[0],
header_size,
info.load_address_,
@@ -522,7 +522,7 @@
}
//==============================================================================
-DynamicImage *DynamicImages::GetExecutableImage() {
+DynamicImage* DynamicImages::GetExecutableImage() {
int executable_index = GetExecutableImageIndex();
if (executable_index >= 0) {
@@ -538,7 +538,7 @@
int image_count = GetImageCount();
for (int i = 0; i < image_count; ++i) {
- DynamicImage *image = GetImage(i);
+ DynamicImage* image = GetImage(i);
if (image->GetFileType() == MH_EXECUTE) {
return i;
}
diff --git a/src/client/mac/handler/dynamic_images.h b/src/client/mac/handler/dynamic_images.h
index 6514790..e81ea7f 100644
--- a/src/client/mac/handler/dynamic_images.h
+++ b/src/client/mac/handler/dynamic_images.h
@@ -108,7 +108,7 @@
// Represents a single dynamically loaded mach-o image
class DynamicImage {
public:
- DynamicImage(uint8_t *header, // data is copied
+ DynamicImage(uint8_t* header, // data is copied
size_t header_size, // includes load commands
uint64_t load_address,
string file_path,
@@ -163,7 +163,7 @@
uint32_t GetVersion() {return version_;}
// For sorting
- bool operator<(const DynamicImage &inInfo) {
+ bool operator<(const DynamicImage& inInfo) {
return GetLoadAddress() < inInfo.GetLoadAddress();
}
@@ -171,8 +171,8 @@
bool IsValid() {return GetVMSize() != 0;}
private:
- DynamicImage(const DynamicImage &);
- DynamicImage &operator=(const DynamicImage &);
+ DynamicImage(const DynamicImage&);
+ DynamicImage& operator=(const DynamicImage&);
friend class DynamicImages;
template<typename MachBits>
@@ -205,26 +205,26 @@
//
class DynamicImageRef {
public:
- explicit DynamicImageRef(DynamicImage *inP) : p(inP) {}
+ explicit DynamicImageRef(DynamicImage* inP) : p(inP) {}
// The copy constructor is required by STL
- DynamicImageRef(const DynamicImageRef &inRef) : p(inRef.p) {}
+ DynamicImageRef(const DynamicImageRef& inRef) : p(inRef.p) {}
- bool operator<(const DynamicImageRef &inRef) const {
+ bool operator<(const DynamicImageRef& inRef) const {
return (*const_cast<DynamicImageRef*>(this)->p)
< (*const_cast<DynamicImageRef&>(inRef).p);
}
- bool operator==(const DynamicImageRef &inInfo) const {
+ bool operator==(const DynamicImageRef& inInfo) const {
return (*const_cast<DynamicImageRef*>(this)->p).GetLoadAddress() ==
(*const_cast<DynamicImageRef&>(inInfo)).GetLoadAddress();
}
// Be just like DynamicImage*
- DynamicImage *operator->() {return p;}
+ DynamicImage* operator->() {return p;}
operator DynamicImage*() {return p;}
private:
- DynamicImage *p;
+ DynamicImage* p;
};
// Helper function to deal with 32-bit/64-bit Mach-O differences.
@@ -250,7 +250,7 @@
int GetImageCount() const {return static_cast<int>(image_list_.size());}
// Returns an individual image.
- DynamicImage *GetImage(int i) {
+ DynamicImage* GetImage(int i) {
if (i < (int)image_list_.size()) {
return image_list_[i];
}
@@ -258,7 +258,7 @@
}
// Returns the image corresponding to the main executable.
- DynamicImage *GetExecutableImage();
+ DynamicImage* GetExecutableImage();
int GetExecutableImageIndex();
// Returns the task which we're looking at.
@@ -312,7 +312,7 @@
kern_return_t ReadTaskMemory(task_port_t target_task,
const uint64_t address,
size_t length,
- vector<uint8_t> &bytes);
+ vector<uint8_t>& bytes);
} // namespace google_breakpad
diff --git a/src/client/mac/handler/exception_handler.cc b/src/client/mac/handler/exception_handler.cc
index 2a19d46..287fe1b 100644
--- a/src/client/mac/handler/exception_handler.cc
+++ b/src/client/mac/handler/exception_handler.cc
@@ -220,7 +220,7 @@
}
#endif
-ExceptionHandler::ExceptionHandler(const string &dump_path,
+ExceptionHandler::ExceptionHandler(const string& dump_path,
FilterCallback filter,
MinidumpCallback callback,
void* callback_context,
@@ -304,7 +304,7 @@
}
// static
-bool ExceptionHandler::WriteMinidump(const string &dump_path,
+bool ExceptionHandler::WriteMinidump(const string& dump_path,
bool write_exception_stream,
MinidumpCallback callback,
void* callback_context) {
@@ -316,7 +316,7 @@
// static
bool ExceptionHandler::WriteMinidumpForChild(mach_port_t child,
mach_port_t child_blamed_thread,
- const string &dump_path,
+ const string& dump_path,
MinidumpCallback callback,
void* callback_context) {
ScopedTaskSuspend suspend(child);
diff --git a/src/client/mac/handler/exception_handler.h b/src/client/mac/handler/exception_handler.h
index f1d9ae9..fe7491f 100644
--- a/src/client/mac/handler/exception_handler.h
+++ b/src/client/mac/handler/exception_handler.h
@@ -75,7 +75,7 @@
// attempting to write a minidump. If a FilterCallback returns false, Breakpad
// will immediately report the exception as unhandled without writing a
// minidump, allowing another handler the opportunity to handle it.
- typedef bool (*FilterCallback)(void *context);
+ typedef bool (*FilterCallback)(void* context);
// A callback function to run after the minidump has been written.
// |minidump_id| is a unique id for the dump, so the minidump
@@ -85,18 +85,18 @@
// Return true if the exception was fully handled and breakpad should exit.
// Return false to allow any other exception handlers to process the
// exception.
- typedef bool (*MinidumpCallback)(const char *dump_dir,
- const char *minidump_id,
- void *context, bool succeeded);
+ typedef bool (*MinidumpCallback)(const char* dump_dir,
+ const char* minidump_id,
+ void* context, bool succeeded);
// A callback function which will be called directly if an exception occurs.
// This bypasses the minidump file writing and simply gives the client
// the exception information.
- typedef bool (*DirectCallback)( void *context,
- int exception_type,
- int exception_code,
- int exception_subcode,
- mach_port_t thread_name);
+ typedef bool (*DirectCallback)(void* context,
+ int exception_type,
+ int exception_code,
+ int exception_subcode,
+ mach_port_t thread_name);
// Creates a new ExceptionHandler instance to handle writing minidumps.
// Minidump files will be written to dump_path, and the optional callback
@@ -106,22 +106,22 @@
// be written when WriteMinidump is called.
// If port_name is non-NULL, attempt to perform out-of-process dump generation
// If port_name is NULL, in-process dump generation will be used.
- ExceptionHandler(const string &dump_path,
+ ExceptionHandler(const string& dump_path,
FilterCallback filter, MinidumpCallback callback,
- void *callback_context, bool install_handler,
- const char *port_name);
+ void* callback_context, bool install_handler,
+ const char* port_name);
// A special constructor if we want to bypass minidump writing and
// simply get a callback with the exception information.
ExceptionHandler(DirectCallback callback,
- void *callback_context,
+ void* callback_context,
bool install_handler);
~ExceptionHandler();
// Get and set the minidump path.
string dump_path() const { return dump_path_; }
- void set_dump_path(const string &dump_path) {
+ void set_dump_path(const string& dump_path) {
dump_path_ = dump_path;
dump_path_c_ = dump_path_.c_str();
UpdateNextID(); // Necessary to put dump_path_ in next_minidump_path_.
@@ -137,23 +137,23 @@
// Convenience form of WriteMinidump which does not require an
// ExceptionHandler instance.
- static bool WriteMinidump(const string &dump_path, MinidumpCallback callback,
- void *callback_context) {
+ static bool WriteMinidump(const string& dump_path, MinidumpCallback callback,
+ void* callback_context) {
return WriteMinidump(dump_path, false, callback, callback_context);
}
- static bool WriteMinidump(const string &dump_path,
+ static bool WriteMinidump(const string& dump_path,
bool write_exception_stream,
MinidumpCallback callback,
- void *callback_context);
+ void* callback_context);
// Write a minidump of child immediately. This can be used to capture
// the execution state of a child process independently of a crash.
static bool WriteMinidumpForChild(mach_port_t child,
- mach_port_t child_blamed_thread,
- const std::string &dump_path,
- MinidumpCallback callback,
- void *callback_context);
+ mach_port_t child_blamed_thread,
+ const std::string& dump_path,
+ MinidumpCallback callback,
+ void* callback_context);
// Returns whether out-of-process dump generation is used or not.
bool IsOutOfProcess() const {
@@ -189,21 +189,21 @@
bool WriteMinidumpWithException(int exception_type,
int exception_code,
int exception_subcode,
- breakpad_ucontext_t *task_context,
+ breakpad_ucontext_t* task_context,
mach_port_t thread_name,
bool exit_after_write,
bool report_current_thread);
// When installed, this static function will be call from a newly created
// pthread with |this| as the argument
- static void *WaitForMessage(void *exception_handler_class);
+ static void* WaitForMessage(void* exception_handler_class);
// Signal handler for SIGABRT.
static void SignalHandler(int sig, siginfo_t* info, void* uc);
// disallow copy ctor and operator=
- explicit ExceptionHandler(const ExceptionHandler &);
- void operator=(const ExceptionHandler &);
+ explicit ExceptionHandler(const ExceptionHandler&);
+ void operator=(const ExceptionHandler&);
// Generates a new ID and stores it in next_minidump_id_, and stores the
// path of the next minidump to be written in next_minidump_path_.
@@ -224,15 +224,15 @@
string next_minidump_path_;
// Pointers to the UTF-8 versions of above
- const char *dump_path_c_;
- const char *next_minidump_id_c_;
- const char *next_minidump_path_c_;
+ const char* dump_path_c_;
+ const char* next_minidump_id_c_;
+ const char* next_minidump_path_c_;
// The callback function and pointer to be passed back after the minidump
// has been written
FilterCallback filter_;
MinidumpCallback callback_;
- void *callback_context_;
+ void* callback_context_;
// The callback function to be passed back when we don't want a minidump
// file to be written
@@ -247,7 +247,7 @@
// These variables save the previous exception handler's data so that it
// can be re-installed when this handler is uninstalled
- ExceptionParameters *previous_;
+ ExceptionParameters* previous_;
// True, if we've installed the exception handler
bool installed_exception_handler_;
diff --git a/src/client/mac/handler/minidump_generator.cc b/src/client/mac/handler/minidump_generator.cc
index 50df900..e0351c4 100644
--- a/src/client/mac/handler/minidump_generator.cc
+++ b/src/client/mac/handler/minidump_generator.cc
@@ -191,12 +191,12 @@
os_build_number_ = IntegerValueAtIndex(product_str, 2);
}
-void MinidumpGenerator::SetTaskContext(breakpad_ucontext_t *task_context) {
+void MinidumpGenerator::SetTaskContext(breakpad_ucontext_t* task_context) {
task_context_ = task_context;
}
-string MinidumpGenerator::UniqueNameInDirectory(const string &dir,
- string *unique_name) {
+string MinidumpGenerator::UniqueNameInDirectory(const string& dir,
+ string* unique_name) {
CFUUIDRef uuid = CFUUIDCreate(NULL);
CFStringRef uuid_cfstr = CFUUIDCreateString(NULL, uuid);
CFRelease(uuid);
@@ -220,7 +220,7 @@
return path;
}
-bool MinidumpGenerator::Write(const char *path) {
+bool MinidumpGenerator::Write(const char* path) {
WriteStreamFN writers[] = {
&MinidumpGenerator::WriteThreadListStream,
&MinidumpGenerator::WriteMemoryListStream,
@@ -256,10 +256,10 @@
if (!dir.AllocateArray(writer_count))
return false;
- MDRawHeader *header_ptr = header.get();
+ MDRawHeader* header_ptr = header.get();
header_ptr->signature = MD_HEADER_SIGNATURE;
header_ptr->version = MD_HEADER_VERSION;
- time(reinterpret_cast<time_t *>(&(header_ptr->time_date_stamp)));
+ time(reinterpret_cast<time_t*>(&(header_ptr->time_date_stamp)));
header_ptr->stream_count = writer_count;
header_ptr->stream_directory_rva = dir.position();
@@ -335,7 +335,7 @@
bool MinidumpGenerator::WriteStackFromStartAddress(
mach_vm_address_t start_addr,
- MDMemoryDescriptor *stack_location) {
+ MDMemoryDescriptor* stack_location) {
UntypedMDRVA memory(&writer_);
bool result = false;
@@ -372,7 +372,7 @@
result = memory.Copy(&stack_memory[0], size);
} else {
- result = memory.Copy(reinterpret_cast<const void *>(start_addr), size);
+ result = memory.Copy(reinterpret_cast<const void*>(start_addr), size);
}
}
@@ -383,7 +383,7 @@
}
bool MinidumpGenerator::WriteStack(breakpad_thread_state_data_t state,
- MDMemoryDescriptor *stack_location) {
+ MDMemoryDescriptor* stack_location) {
switch (cpu_type_) {
#ifdef HAS_ARM_SUPPORT
case CPU_TYPE_ARM:
@@ -411,7 +411,7 @@
}
bool MinidumpGenerator::WriteContext(breakpad_thread_state_data_t state,
- MDLocationDescriptor *register_location) {
+ MDLocationDescriptor* register_location) {
switch (cpu_type_) {
#ifdef HAS_ARM_SUPPORT
case CPU_TYPE_ARM:
@@ -469,33 +469,33 @@
#ifdef HAS_ARM_SUPPORT
bool MinidumpGenerator::WriteStackARM(breakpad_thread_state_data_t state,
- MDMemoryDescriptor *stack_location) {
- arm_thread_state_t *machine_state =
- reinterpret_cast<arm_thread_state_t *>(state);
+ MDMemoryDescriptor* stack_location) {
+ arm_thread_state_t* machine_state =
+ reinterpret_cast<arm_thread_state_t*>(state);
mach_vm_address_t start_addr = REGISTER_FROM_THREADSTATE(machine_state, sp);
return WriteStackFromStartAddress(start_addr, stack_location);
}
uint64_t
MinidumpGenerator::CurrentPCForStackARM(breakpad_thread_state_data_t state) {
- arm_thread_state_t *machine_state =
- reinterpret_cast<arm_thread_state_t *>(state);
+ arm_thread_state_t* machine_state =
+ reinterpret_cast<arm_thread_state_t*>(state);
return REGISTER_FROM_THREADSTATE(machine_state, pc);
}
bool MinidumpGenerator::WriteContextARM(breakpad_thread_state_data_t state,
- MDLocationDescriptor *register_location)
+ MDLocationDescriptor* register_location)
{
TypedMDRVA<MDRawContextARM> context(&writer_);
- arm_thread_state_t *machine_state =
- reinterpret_cast<arm_thread_state_t *>(state);
+ arm_thread_state_t* machine_state =
+ reinterpret_cast<arm_thread_state_t*>(state);
if (!context.Allocate())
return false;
*register_location = context.location();
- MDRawContextARM *context_ptr = context.get();
+ MDRawContextARM* context_ptr = context.get();
context_ptr->context_flags = MD_CONTEXT_ARM_FULL;
#define AddGPR(a) context_ptr->iregs[a] = REGISTER_FROM_THREADSTATE(machine_state, r[a])
@@ -526,34 +526,34 @@
#ifdef HAS_ARM64_SUPPORT
bool MinidumpGenerator::WriteStackARM64(breakpad_thread_state_data_t state,
- MDMemoryDescriptor *stack_location) {
- arm_thread_state64_t *machine_state =
- reinterpret_cast<arm_thread_state64_t *>(state);
+ MDMemoryDescriptor* stack_location) {
+ arm_thread_state64_t* machine_state =
+ reinterpret_cast<arm_thread_state64_t*>(state);
mach_vm_address_t start_addr = REGISTER_FROM_THREADSTATE(machine_state, sp);
return WriteStackFromStartAddress(start_addr, stack_location);
}
uint64_t
MinidumpGenerator::CurrentPCForStackARM64(breakpad_thread_state_data_t state) {
- arm_thread_state64_t *machine_state =
- reinterpret_cast<arm_thread_state64_t *>(state);
+ arm_thread_state64_t* machine_state =
+ reinterpret_cast<arm_thread_state64_t*>(state);
return REGISTER_FROM_THREADSTATE(machine_state, pc);
}
bool
MinidumpGenerator::WriteContextARM64(breakpad_thread_state_data_t state,
- MDLocationDescriptor *register_location)
+ MDLocationDescriptor* register_location)
{
TypedMDRVA<MDRawContextARM64_Old> context(&writer_);
- arm_thread_state64_t *machine_state =
- reinterpret_cast<arm_thread_state64_t *>(state);
+ arm_thread_state64_t* machine_state =
+ reinterpret_cast<arm_thread_state64_t*>(state);
if (!context.Allocate())
return false;
*register_location = context.location();
- MDRawContextARM64_Old *context_ptr = context.get();
+ MDRawContextARM64_Old* context_ptr = context.get();
context_ptr->context_flags = MD_CONTEXT_ARM64_FULL_OLD;
#define AddGPR(a) \
@@ -602,49 +602,49 @@
#ifdef HAS_PCC_SUPPORT
bool MinidumpGenerator::WriteStackPPC(breakpad_thread_state_data_t state,
- MDMemoryDescriptor *stack_location) {
- ppc_thread_state_t *machine_state =
- reinterpret_cast<ppc_thread_state_t *>(state);
+ MDMemoryDescriptor* stack_location) {
+ ppc_thread_state_t* machine_state =
+ reinterpret_cast<ppc_thread_state_t*>(state);
mach_vm_address_t start_addr = REGISTER_FROM_THREADSTATE(machine_state, r1);
return WriteStackFromStartAddress(start_addr, stack_location);
}
bool MinidumpGenerator::WriteStackPPC64(breakpad_thread_state_data_t state,
- MDMemoryDescriptor *stack_location) {
- ppc_thread_state64_t *machine_state =
- reinterpret_cast<ppc_thread_state64_t *>(state);
+ MDMemoryDescriptor* stack_location) {
+ ppc_thread_state64_t* machine_state =
+ reinterpret_cast<ppc_thread_state64_t*>(state);
mach_vm_address_t start_addr = REGISTER_FROM_THREADSTATE(machine_state, r1);
return WriteStackFromStartAddress(start_addr, stack_location);
}
uint64_t
MinidumpGenerator::CurrentPCForStackPPC(breakpad_thread_state_data_t state) {
- ppc_thread_state_t *machine_state =
- reinterpret_cast<ppc_thread_state_t *>(state);
+ ppc_thread_state_t* machine_state =
+ reinterpret_cast<ppc_thread_state_t*>(state);
return REGISTER_FROM_THREADSTATE(machine_state, srr0);
}
uint64_t
MinidumpGenerator::CurrentPCForStackPPC64(breakpad_thread_state_data_t state) {
- ppc_thread_state64_t *machine_state =
- reinterpret_cast<ppc_thread_state64_t *>(state);
+ ppc_thread_state64_t* machine_state =
+ reinterpret_cast<ppc_thread_state64_t*>(state);
return REGISTER_FROM_THREADSTATE(machine_state, srr0);
}
bool MinidumpGenerator::WriteContextPPC(breakpad_thread_state_data_t state,
- MDLocationDescriptor *register_location)
+ MDLocationDescriptor* register_location)
{
TypedMDRVA<MDRawContextPPC> context(&writer_);
- ppc_thread_state_t *machine_state =
- reinterpret_cast<ppc_thread_state_t *>(state);
+ ppc_thread_state_t* machine_state =
+ reinterpret_cast<ppc_thread_state_t*>(state);
if (!context.Allocate())
return false;
*register_location = context.location();
- MDRawContextPPC *context_ptr = context.get();
+ MDRawContextPPC* context_ptr = context.get();
context_ptr->context_flags = MD_CONTEXT_PPC_BASE;
#define AddReg(a) context_ptr->a = static_cast<__typeof__(context_ptr->a)>( \
@@ -701,16 +701,16 @@
bool MinidumpGenerator::WriteContextPPC64(
breakpad_thread_state_data_t state,
- MDLocationDescriptor *register_location) {
+ MDLocationDescriptor* register_location) {
TypedMDRVA<MDRawContextPPC64> context(&writer_);
- ppc_thread_state64_t *machine_state =
- reinterpret_cast<ppc_thread_state64_t *>(state);
+ ppc_thread_state64_t* machine_state =
+ reinterpret_cast<ppc_thread_state64_t*>(state);
if (!context.Allocate())
return false;
*register_location = context.location();
- MDRawContextPPC64 *context_ptr = context.get();
+ MDRawContextPPC64* context_ptr = context.get();
context_ptr->context_flags = MD_CONTEXT_PPC_BASE;
#define AddReg(a) context_ptr->a = static_cast<__typeof__(context_ptr->a)>( \
@@ -768,18 +768,18 @@
#ifdef HAS_X86_SUPPORT
bool MinidumpGenerator::WriteStackX86(breakpad_thread_state_data_t state,
- MDMemoryDescriptor *stack_location) {
- i386_thread_state_t *machine_state =
- reinterpret_cast<i386_thread_state_t *>(state);
+ MDMemoryDescriptor* stack_location) {
+ i386_thread_state_t* machine_state =
+ reinterpret_cast<i386_thread_state_t*>(state);
mach_vm_address_t start_addr = REGISTER_FROM_THREADSTATE(machine_state, esp);
return WriteStackFromStartAddress(start_addr, stack_location);
}
bool MinidumpGenerator::WriteStackX86_64(breakpad_thread_state_data_t state,
- MDMemoryDescriptor *stack_location) {
- x86_thread_state64_t *machine_state =
- reinterpret_cast<x86_thread_state64_t *>(state);
+ MDMemoryDescriptor* stack_location) {
+ x86_thread_state64_t* machine_state =
+ reinterpret_cast<x86_thread_state64_t*>(state);
mach_vm_address_t start_addr = static_cast<mach_vm_address_t>(
REGISTER_FROM_THREADSTATE(machine_state, rsp));
@@ -788,32 +788,32 @@
uint64_t
MinidumpGenerator::CurrentPCForStackX86(breakpad_thread_state_data_t state) {
- i386_thread_state_t *machine_state =
- reinterpret_cast<i386_thread_state_t *>(state);
+ i386_thread_state_t* machine_state =
+ reinterpret_cast<i386_thread_state_t*>(state);
return REGISTER_FROM_THREADSTATE(machine_state, eip);
}
uint64_t
MinidumpGenerator::CurrentPCForStackX86_64(breakpad_thread_state_data_t state) {
- x86_thread_state64_t *machine_state =
- reinterpret_cast<x86_thread_state64_t *>(state);
+ x86_thread_state64_t* machine_state =
+ reinterpret_cast<x86_thread_state64_t*>(state);
return REGISTER_FROM_THREADSTATE(machine_state, rip);
}
bool MinidumpGenerator::WriteContextX86(breakpad_thread_state_data_t state,
- MDLocationDescriptor *register_location)
+ MDLocationDescriptor* register_location)
{
TypedMDRVA<MDRawContextX86> context(&writer_);
- i386_thread_state_t *machine_state =
- reinterpret_cast<i386_thread_state_t *>(state);
+ i386_thread_state_t* machine_state =
+ reinterpret_cast<i386_thread_state_t*>(state);
if (!context.Allocate())
return false;
*register_location = context.location();
- MDRawContextX86 *context_ptr = context.get();
+ MDRawContextX86* context_ptr = context.get();
#define AddReg(a) context_ptr->a = static_cast<__typeof__(context_ptr->a)>( \
REGISTER_FROM_THREADSTATE(machine_state, a))
@@ -844,16 +844,16 @@
bool MinidumpGenerator::WriteContextX86_64(
breakpad_thread_state_data_t state,
- MDLocationDescriptor *register_location) {
+ MDLocationDescriptor* register_location) {
TypedMDRVA<MDRawContextAMD64> context(&writer_);
- x86_thread_state64_t *machine_state =
- reinterpret_cast<x86_thread_state64_t *>(state);
+ x86_thread_state64_t* machine_state =
+ reinterpret_cast<x86_thread_state64_t*>(state);
if (!context.Allocate())
return false;
*register_location = context.location();
- MDRawContextAMD64 *context_ptr = context.get();
+ MDRawContextAMD64* context_ptr = context.get();
#define AddReg(a) context_ptr->a = static_cast<__typeof__(context_ptr->a)>( \
REGISTER_FROM_THREADSTATE(machine_state, a))
@@ -892,7 +892,7 @@
bool MinidumpGenerator::GetThreadState(thread_act_t target_thread,
thread_state_t state,
- mach_msg_type_number_t *count) {
+ mach_msg_type_number_t* count) {
if (task_context_ && target_thread == mach_thread_self()) {
switch (cpu_type_) {
#ifdef HAS_ARM_SUPPORT
@@ -963,7 +963,7 @@
}
bool MinidumpGenerator::WriteThreadStream(mach_port_t thread_id,
- MDRawThread *thread) {
+ MDRawThread* thread) {
breakpad_thread_state_data_t state;
mach_msg_type_number_t state_count
= static_cast<mach_msg_type_number_t>(sizeof(state));
@@ -986,7 +986,7 @@
}
bool MinidumpGenerator::WriteThreadListStream(
- MDRawDirectory *thread_list_stream) {
+ MDRawDirectory* thread_list_stream) {
TypedMDRVA<MDRawThreadList> list(&writer_);
thread_act_port_array_t threads_for_task;
mach_msg_type_number_t thread_count;
@@ -1027,7 +1027,7 @@
}
bool MinidumpGenerator::WriteMemoryListStream(
- MDRawDirectory *memory_list_stream) {
+ MDRawDirectory* memory_list_stream) {
TypedMDRVA<MDRawMemoryList> list(&writer_);
// If the dump has an exception, include some memory around the
@@ -1119,7 +1119,7 @@
} else {
// In-process, just copy from local memory.
ip_memory.Copy(
- reinterpret_cast<const void *>(ip_memory_d.start_of_memory_range),
+ reinterpret_cast<const void*>(ip_memory_d.start_of_memory_range),
ip_memory_d.memory.data_size);
}
@@ -1133,7 +1133,7 @@
}
bool
-MinidumpGenerator::WriteExceptionStream(MDRawDirectory *exception_stream) {
+MinidumpGenerator::WriteExceptionStream(MDRawDirectory* exception_stream) {
TypedMDRVA<MDRawExceptionStream> exception(&writer_);
if (!exception.Allocate())
@@ -1141,7 +1141,7 @@
exception_stream->stream_type = MD_EXCEPTION_STREAM;
exception_stream->location = exception.location();
- MDRawExceptionStream *exception_ptr = exception.get();
+ MDRawExceptionStream* exception_ptr = exception.get();
exception_ptr->thread_id = exception_thread_;
// This naming is confusing, but it is the proper translation from
@@ -1168,7 +1168,7 @@
}
bool MinidumpGenerator::WriteSystemInfoStream(
- MDRawDirectory *system_info_stream) {
+ MDRawDirectory* system_info_stream) {
TypedMDRVA<MDRawSystemInfo> info(&writer_);
if (!info.Allocate())
@@ -1181,7 +1181,7 @@
uint32_t number_of_processors;
size_t len = sizeof(number_of_processors);
sysctlbyname("hw.ncpu", &number_of_processors, &len, NULL, 0);
- MDRawSystemInfo *info_ptr = info.get();
+ MDRawSystemInfo* info_ptr = info.get();
switch (cpu_type_) {
#ifdef HAS_ARM_SUPPORT
@@ -1292,10 +1292,10 @@
}
bool MinidumpGenerator::WriteModuleStream(unsigned int index,
- MDRawModule *module) {
+ MDRawModule* module) {
if (dynamic_images_) {
// we're in a different process than the crashed process
- DynamicImage *image = dynamic_images_->GetImage(index);
+ DynamicImage* image = dynamic_images_->GetImage(index);
if (!image)
return false;
@@ -1337,7 +1337,7 @@
}
} else {
// Getting module info in the crashed process
- const breakpad_mach_header *header;
+ const breakpad_mach_header* header;
header = (breakpad_mach_header*)_dyld_get_image_header(index);
if (!header)
return false;
@@ -1357,16 +1357,16 @@
int cpu_type = header->cputype;
unsigned long slide = _dyld_get_image_vmaddr_slide(index);
const char* name = _dyld_get_image_name(index);
- const struct load_command *cmd =
- reinterpret_cast<const struct load_command *>(header + 1);
+ const struct load_command* cmd =
+ reinterpret_cast<const struct load_command*>(header + 1);
memset(module, 0, sizeof(MDRawModule));
for (unsigned int i = 0; cmd && (i < header->ncmds); i++) {
if (cmd->cmd == LC_SEGMENT_ARCH) {
- const breakpad_mach_segment_command *seg =
- reinterpret_cast<const breakpad_mach_segment_command *>(cmd);
+ const breakpad_mach_segment_command* seg =
+ reinterpret_cast<const breakpad_mach_segment_command*>(cmd);
if (!strcmp(seg->segname, "__TEXT")) {
MDLocationDescriptor string_location;
@@ -1389,7 +1389,7 @@
}
}
- cmd = reinterpret_cast<struct load_command*>((char *)cmd + cmd->cmdsize);
+ cmd = reinterpret_cast<struct load_command*>((char*)cmd + cmd->cmdsize);
}
}
@@ -1405,7 +1405,7 @@
}
} else {
int image_count = _dyld_image_count();
- const struct mach_header *header;
+ const struct mach_header* header;
for (int index = 0; index < image_count; ++index) {
header = _dyld_get_image_header(index);
@@ -1419,12 +1419,12 @@
return 0;
}
-bool MinidumpGenerator::WriteCVRecord(MDRawModule *module, int cpu_type,
- const char *module_path, bool in_memory) {
+bool MinidumpGenerator::WriteCVRecord(MDRawModule* module, int cpu_type,
+ const char* module_path, bool in_memory) {
TypedMDRVA<MDCVInfoPDB70> cv(&writer_);
// Only return the last path component of the full module path
- const char *module_name = strrchr(module_path, '/');
+ const char* module_name = strrchr(module_path, '/');
// Increment past the slash
if (module_name)
@@ -1441,7 +1441,7 @@
return false;
module->cv_record = cv.location();
- MDCVInfoPDB70 *cv_ptr = cv.get();
+ MDCVInfoPDB70* cv_ptr = cv.get();
cv_ptr->cv_signature = MD_CVINFOPDB70_SIGNATURE;
cv_ptr->age = 0;
@@ -1450,7 +1450,7 @@
bool result = false;
if (in_memory) {
MacFileUtilities::MachoID macho(module_path,
- reinterpret_cast<void *>(module->base_of_image),
+ reinterpret_cast<void*>(module->base_of_image),
static_cast<size_t>(module->size_of_image));
result = macho.UUIDCommand(cpu_type, CPU_SUBTYPE_MULTIPLE, identifier);
if (!result)
@@ -1487,7 +1487,7 @@
}
bool MinidumpGenerator::WriteModuleListStream(
- MDRawDirectory *module_list_stream) {
+ MDRawDirectory* module_list_stream) {
TypedMDRVA<MDRawModuleList> list(&writer_);
uint32_t image_count = dynamic_images_ ?
@@ -1525,7 +1525,7 @@
return true;
}
-bool MinidumpGenerator::WriteMiscInfoStream(MDRawDirectory *misc_info_stream) {
+bool MinidumpGenerator::WriteMiscInfoStream(MDRawDirectory* misc_info_stream) {
TypedMDRVA<MDRawMiscInfo> info(&writer_);
if (!info.Allocate())
@@ -1534,7 +1534,7 @@
misc_info_stream->stream_type = MD_MISC_INFO_STREAM;
misc_info_stream->location = info.location();
- MDRawMiscInfo *info_ptr = info.get();
+ MDRawMiscInfo* info_ptr = info.get();
info_ptr->size_of_info = static_cast<uint32_t>(sizeof(MDRawMiscInfo));
info_ptr->flags1 = MD_MISCINFO_FLAGS1_PROCESS_ID |
MD_MISCINFO_FLAGS1_PROCESS_TIMES |
@@ -1577,7 +1577,7 @@
}
bool MinidumpGenerator::WriteBreakpadInfoStream(
- MDRawDirectory *breakpad_info_stream) {
+ MDRawDirectory* breakpad_info_stream) {
TypedMDRVA<MDRawBreakpadInfo> info(&writer_);
if (!info.Allocate())
@@ -1585,7 +1585,7 @@
breakpad_info_stream->stream_type = MD_BREAKPAD_INFO_STREAM;
breakpad_info_stream->location = info.location();
- MDRawBreakpadInfo *info_ptr = info.get();
+ MDRawBreakpadInfo* info_ptr = info.get();
if (exception_thread_ && exception_type_) {
info_ptr->validity = MD_BREAKPAD_INFO_VALID_DUMP_THREAD_ID |
diff --git a/src/client/mac/handler/minidump_generator.h b/src/client/mac/handler/minidump_generator.h
index f3aa9bd..e3a271b 100644
--- a/src/client/mac/handler/minidump_generator.h
+++ b/src/client/mac/handler/minidump_generator.h
@@ -106,12 +106,12 @@
// Return <dir>/<unique_name>.dmp
// Sets |unique_name| (if requested) to the unique name for the minidump
- static string UniqueNameInDirectory(const string &dir, string *unique_name);
+ static string UniqueNameInDirectory(const string& dir, string* unique_name);
// Write out the minidump into |path|
// All of the components of |path| must exist and be writable
// Return true if successful, false otherwise
- bool Write(const char *path);
+ bool Write(const char* path);
// Specify some exception information, if applicable
void SetExceptionInformation(int type, int code, int subcode,
@@ -125,7 +125,7 @@
// Specify the task context. If |task_context| is not NULL, it will be used
// to retrieve the context of the current thread, instead of using
// |thread_get_state|.
- void SetTaskContext(breakpad_ucontext_t *task_context);
+ void SetTaskContext(breakpad_ucontext_t* task_context);
// Gather system information. This should be call at least once before using
// the MinidumpGenerator class.
@@ -133,81 +133,81 @@
protected:
// Overridable Stream writers
- virtual bool WriteExceptionStream(MDRawDirectory *exception_stream);
+ virtual bool WriteExceptionStream(MDRawDirectory* exception_stream);
// Overridable Helper
- virtual bool WriteThreadStream(mach_port_t thread_id, MDRawThread *thread);
+ virtual bool WriteThreadStream(mach_port_t thread_id, MDRawThread* thread);
private:
- typedef bool (MinidumpGenerator::*WriteStreamFN)(MDRawDirectory *);
+ typedef bool (MinidumpGenerator::*WriteStreamFN)(MDRawDirectory*);
// Stream writers
- bool WriteThreadListStream(MDRawDirectory *thread_list_stream);
- bool WriteMemoryListStream(MDRawDirectory *memory_list_stream);
- bool WriteSystemInfoStream(MDRawDirectory *system_info_stream);
- bool WriteModuleListStream(MDRawDirectory *module_list_stream);
- bool WriteMiscInfoStream(MDRawDirectory *misc_info_stream);
- bool WriteBreakpadInfoStream(MDRawDirectory *breakpad_info_stream);
+ bool WriteThreadListStream(MDRawDirectory* thread_list_stream);
+ bool WriteMemoryListStream(MDRawDirectory* memory_list_stream);
+ bool WriteSystemInfoStream(MDRawDirectory* system_info_stream);
+ bool WriteModuleListStream(MDRawDirectory* module_list_stream);
+ bool WriteMiscInfoStream(MDRawDirectory* misc_info_stream);
+ bool WriteBreakpadInfoStream(MDRawDirectory* breakpad_info_stream);
// Helpers
uint64_t CurrentPCForStack(breakpad_thread_state_data_t state);
bool GetThreadState(thread_act_t target_thread, thread_state_t state,
- mach_msg_type_number_t *count);
+ mach_msg_type_number_t* count);
bool WriteStackFromStartAddress(mach_vm_address_t start_addr,
- MDMemoryDescriptor *stack_location);
+ MDMemoryDescriptor* stack_location);
bool WriteStack(breakpad_thread_state_data_t state,
- MDMemoryDescriptor *stack_location);
+ MDMemoryDescriptor* stack_location);
bool WriteContext(breakpad_thread_state_data_t state,
- MDLocationDescriptor *register_location);
- bool WriteCVRecord(MDRawModule *module, int cpu_type,
- const char *module_path, bool in_memory);
- bool WriteModuleStream(unsigned int index, MDRawModule *module);
+ MDLocationDescriptor* register_location);
+ bool WriteCVRecord(MDRawModule* module, int cpu_type,
+ const char* module_path, bool in_memory);
+ bool WriteModuleStream(unsigned int index, MDRawModule* module);
size_t CalculateStackSize(mach_vm_address_t start_addr);
int FindExecutableModule();
// Per-CPU implementations of these methods
#ifdef HAS_ARM_SUPPORT
bool WriteStackARM(breakpad_thread_state_data_t state,
- MDMemoryDescriptor *stack_location);
+ MDMemoryDescriptor* stack_location);
bool WriteContextARM(breakpad_thread_state_data_t state,
- MDLocationDescriptor *register_location);
+ MDLocationDescriptor* register_location);
uint64_t CurrentPCForStackARM(breakpad_thread_state_data_t state);
#endif
#ifdef HAS_ARM64_SUPPORT
bool WriteStackARM64(breakpad_thread_state_data_t state,
- MDMemoryDescriptor *stack_location);
+ MDMemoryDescriptor* stack_location);
bool WriteContextARM64(breakpad_thread_state_data_t state,
- MDLocationDescriptor *register_location);
+ MDLocationDescriptor* register_location);
uint64_t CurrentPCForStackARM64(breakpad_thread_state_data_t state);
#endif
#ifdef HAS_PPC_SUPPORT
bool WriteStackPPC(breakpad_thread_state_data_t state,
- MDMemoryDescriptor *stack_location);
+ MDMemoryDescriptor* stack_location);
bool WriteContextPPC(breakpad_thread_state_data_t state,
- MDLocationDescriptor *register_location);
+ MDLocationDescriptor* register_location);
uint64_t CurrentPCForStackPPC(breakpad_thread_state_data_t state);
bool WriteStackPPC64(breakpad_thread_state_data_t state,
- MDMemoryDescriptor *stack_location);
+ MDMemoryDescriptor* stack_location);
bool WriteContextPPC64(breakpad_thread_state_data_t state,
- MDLocationDescriptor *register_location);
+ MDLocationDescriptor* register_location);
uint64_t CurrentPCForStackPPC64(breakpad_thread_state_data_t state);
#endif
#ifdef HAS_X86_SUPPORT
bool WriteStackX86(breakpad_thread_state_data_t state,
- MDMemoryDescriptor *stack_location);
+ MDMemoryDescriptor* stack_location);
bool WriteContextX86(breakpad_thread_state_data_t state,
- MDLocationDescriptor *register_location);
+ MDLocationDescriptor* register_location);
uint64_t CurrentPCForStackX86(breakpad_thread_state_data_t state);
bool WriteStackX86_64(breakpad_thread_state_data_t state,
- MDMemoryDescriptor *stack_location);
+ MDMemoryDescriptor* stack_location);
bool WriteContextX86_64(breakpad_thread_state_data_t state,
- MDLocationDescriptor *register_location);
+ MDLocationDescriptor* register_location);
uint64_t CurrentPCForStackX86_64(breakpad_thread_state_data_t state);
#endif
// disallow copy ctor and operator=
- explicit MinidumpGenerator(const MinidumpGenerator &);
- void operator=(const MinidumpGenerator &);
+ explicit MinidumpGenerator(const MinidumpGenerator&);
+ void operator=(const MinidumpGenerator&);
protected:
// Use this writer to put the data to disk
@@ -232,10 +232,10 @@
static int os_build_number_;
// Context of the task to dump.
- breakpad_ucontext_t *task_context_;
+ breakpad_ucontext_t* task_context_;
// Information about dynamically loaded code
- DynamicImages *dynamic_images_;
+ DynamicImages* dynamic_images_;
// PageAllocator makes it possible to allocate memory
// directly from the system, even while handling an exception.
diff --git a/src/client/mac/handler/testcases/DynamicImagesTests.cc b/src/client/mac/handler/testcases/DynamicImagesTests.cc
index 0fc7825..0a80e43 100644
--- a/src/client/mac/handler/testcases/DynamicImagesTests.cc
+++ b/src/client/mac/handler/testcases/DynamicImagesTests.cc
@@ -42,7 +42,7 @@
DynamicImagesTests test3(TEST_INVOCATION(DynamicImagesTests,
ReadLibrariesFromLocalTaskTest));
-DynamicImagesTests::DynamicImagesTests(TestInvocation *invocation)
+DynamicImagesTests::DynamicImagesTests(TestInvocation* invocation)
: TestCase(invocation) {
}
@@ -54,7 +54,7 @@
// pick test2 as a symbol we know to be valid to read
// anything will work, really
- void *addr = reinterpret_cast<void*>(&test2);
+ void* addr = reinterpret_cast<void*>(&test2);
std::vector<uint8_t> buf(getpagesize());
fprintf(stderr, "reading 0x%p\n", addr);
@@ -71,7 +71,7 @@
void DynamicImagesTests::ReadLibrariesFromLocalTaskTest() {
mach_port_t me = mach_task_self();
- google_breakpad::DynamicImages *d = new google_breakpad::DynamicImages(me);
+ google_breakpad::DynamicImages* d = new google_breakpad::DynamicImages(me);
fprintf(stderr,"Local task image count: %d\n", d->GetImageCount());
diff --git a/src/client/mac/handler/testcases/breakpad_nlist_test.cc b/src/client/mac/handler/testcases/breakpad_nlist_test.cc
index e7332bf..2014b90 100644
--- a/src/client/mac/handler/testcases/breakpad_nlist_test.cc
+++ b/src/client/mac/handler/testcases/breakpad_nlist_test.cc
@@ -40,7 +40,7 @@
BreakpadNlistTest test1(TEST_INVOCATION(BreakpadNlistTest, CompareToNM));
-BreakpadNlistTest::BreakpadNlistTest(TestInvocation *invocation)
+BreakpadNlistTest::BreakpadNlistTest(TestInvocation* invocation)
: TestCase(invocation) {
}
@@ -55,7 +55,7 @@
system("/usr/bin/nm -arch ppc64 /usr/lib/dyld > /tmp/dyld-namelist.txt");
#endif
- FILE *fd = fopen("/tmp/dyld-namelist.txt", "rt");
+ FILE* fd = fopen("/tmp/dyld-namelist.txt", "rt");
char oneNMAddr[30];
char symbolType;
@@ -63,10 +63,10 @@
while (!feof(fd)) {
fscanf(fd, "%s %c %s", oneNMAddr, &symbolType, symbolName);
breakpad_nlist symbolList[2];
- breakpad_nlist &list = symbolList[0];
+ breakpad_nlist& list = symbolList[0];
memset(symbolList, 0, sizeof(breakpad_nlist)*2);
- const char *symbolNames[2];
+ const char* symbolNames[2];
symbolNames[0] = (const char*)symbolName;
symbolNames[1] = "\0";
breakpad_nlist_64("/usr/lib/dyld", &list, symbolNames);
@@ -79,12 +79,12 @@
fclose(fd);
}
-bool BreakpadNlistTest::IsSymbolMoreThanOnceInDyld(const char *symbolName) {
+bool BreakpadNlistTest::IsSymbolMoreThanOnceInDyld(const char* symbolName) {
// These are the symbols that occur more than once when nm dumps
// the symbol table of /usr/lib/dyld. Our nlist program returns
// the first address because it's doing a search so we need to exclude
// these from causing the test to fail
- const char *multipleSymbols[] = {
+ const char* multipleSymbols[] = {
"__Z41__static_initialization_and_destruction_0ii",
"___tcf_0",
"___tcf_1",
diff --git a/src/client/mac/handler/testcases/breakpad_nlist_test.h b/src/client/mac/handler/testcases/breakpad_nlist_test.h
index e93657c..ee8010c 100644
--- a/src/client/mac/handler/testcases/breakpad_nlist_test.h
+++ b/src/client/mac/handler/testcases/breakpad_nlist_test.h
@@ -47,7 +47,7 @@
// /usr/lib/dyld. So we track those so we don't report failures
// in mismatches between what our nlist returns and what nm has
// for the duplicate symbols.
- bool IsSymbolMoreThanOnceInDyld(const char *symbolName);
+ bool IsSymbolMoreThanOnceInDyld(const char* symbolName);
public:
explicit BreakpadNlistTest(TestInvocation* invocation);
diff --git a/src/client/mac/testapp/main.m b/src/client/mac/testapp/main.m
index 1ed19bf..de67332 100644
--- a/src/client/mac/testapp/main.m
+++ b/src/client/mac/testapp/main.m
@@ -30,5 +30,5 @@
#import <Cocoa/Cocoa.h>
int main(int argc, char *argv[]) {
- return NSApplicationMain(argc, (const char **) argv);
+ return NSApplicationMain(argc, (const char**)argv);
}
diff --git a/src/client/mac/tests/crash_generation_server_test.cc b/src/client/mac/tests/crash_generation_server_test.cc
index 0164f4a..128f25c 100644
--- a/src/client/mac/tests/crash_generation_server_test.cc
+++ b/src/client/mac/tests/crash_generation_server_test.cc
@@ -147,8 +147,8 @@
globfree(&dirContents);
}
-void dumpCallback(void *context, const ClientInfo &client_info,
- const std::string &file_path) {
+void dumpCallback(void* context, const ClientInfo& client_info,
+ const std::string& file_path) {
if (context) {
CrashGenerationServerTest* self =
reinterpret_cast<CrashGenerationServerTest*>(context);
@@ -158,7 +158,7 @@
}
}
-void *RequestDump(void *context) {
+void* RequestDump(void* context) {
CrashGenerationClient client((const char*)context);
bool result = client.RequestDump();
return (void*)(result ? 0 : 1);
@@ -206,7 +206,7 @@
}
static void Crasher() {
- int *a = (int*)0x42;
+ int* a = (int*)0x42;
fprintf(stdout, "Going to crash...\n");
fprintf(stdout, "A = %d", *a);
diff --git a/src/client/mac/tests/exception_handler_test.cc b/src/client/mac/tests/exception_handler_test.cc
index d5b505a..50f03f8 100644
--- a/src/client/mac/tests/exception_handler_test.cc
+++ b/src/client/mac/tests/exception_handler_test.cc
@@ -71,7 +71,7 @@
};
static void Crasher() {
- int *a = (int*)0x42;
+ int* a = (int*)0x42;
fprintf(stdout, "Going to crash...\n");
fprintf(stdout, "A = %d", *a);
@@ -86,8 +86,8 @@
crasher();
}
-static bool MDCallback(const char *dump_dir, const char *file_name,
- void *context, bool success) {
+static bool MDCallback(const char* dump_dir, const char* file_name,
+ void* context, bool success) {
string path(dump_dir);
path.append("/");
path.append(file_name);
@@ -179,9 +179,9 @@
InProcessCrash(true);
}
-static bool DumpNameMDCallback(const char *dump_dir, const char *file_name,
- void *context, bool success) {
- ExceptionHandlerTest *self = reinterpret_cast<ExceptionHandlerTest*>(context);
+static bool DumpNameMDCallback(const char* dump_dir, const char* file_name,
+ void* context, bool success) {
+ ExceptionHandlerTest* self = reinterpret_cast<ExceptionHandlerTest*>(context);
if (dump_dir && file_name) {
self->lastDumpName = dump_dir;
self->lastDumpName += "/";
@@ -652,7 +652,7 @@
ASSERT_EQ((unsigned int)1, memory_list->region_count());
}
-static void *Junk(void *) {
+static void* Junk(void*) {
sleep(1000000);
return NULL;
}
diff --git a/src/client/mac/tests/minidump_generator_test.cc b/src/client/mac/tests/minidump_generator_test.cc
index b1fa5d0..1f37465 100644
--- a/src/client/mac/tests/minidump_generator_test.cc
+++ b/src/client/mac/tests/minidump_generator_test.cc
@@ -79,7 +79,7 @@
AutoTempDir tempDir;
};
-static void *Junk(void* data) {
+static void* Junk(void* data) {
bool* wait = reinterpret_cast<bool*>(data);
while (!*wait) {
usleep(10000);
diff --git a/src/client/minidump_file_writer-inl.h b/src/client/minidump_file_writer-inl.h
index 0e12e00..bdac2da 100644
--- a/src/client/minidump_file_writer-inl.h
+++ b/src/client/minidump_file_writer-inl.h
@@ -69,7 +69,7 @@
}
template<typename MDType>
-inline bool TypedMDRVA<MDType>::CopyIndex(unsigned int index, MDType *item) {
+inline bool TypedMDRVA<MDType>::CopyIndex(unsigned int index, MDType* item) {
assert(allocation_state_ == ARRAY);
return writer_->Copy(
static_cast<MDRVA>(position_ + index * minidump_size<MDType>::size()),
@@ -78,7 +78,7 @@
template<typename MDType>
inline bool TypedMDRVA<MDType>::CopyIndexAfterObject(unsigned int index,
- const void *src,
+ const void* src,
size_t length) {
assert(allocation_state_ == SINGLE_OBJECT_WITH_ARRAY);
return writer_->Copy(
diff --git a/src/client/minidump_file_writer.cc b/src/client/minidump_file_writer.cc
index a1957f3..5c3c5cb 100644
--- a/src/client/minidump_file_writer.cc
+++ b/src/client/minidump_file_writer.cc
@@ -101,7 +101,7 @@
Close();
}
-bool MinidumpFileWriter::Open(const char *path) {
+bool MinidumpFileWriter::Open(const char* path) {
assert(file_ == -1);
#if defined(__linux__) && __linux__
file_ = sys_open(path, O_WRONLY | O_CREAT | O_EXCL, 0600);
@@ -145,9 +145,9 @@
return result;
}
-bool MinidumpFileWriter::CopyStringToMDString(const wchar_t *str,
+bool MinidumpFileWriter::CopyStringToMDString(const wchar_t* str,
unsigned int length,
- TypedMDRVA<MDString> *mdstring) {
+ TypedMDRVA<MDString>* mdstring) {
bool result = true;
if (sizeof(wchar_t) == sizeof(uint16_t)) {
// Shortcut if wchar_t is the same size as MDString's buffer
@@ -178,9 +178,9 @@
return result;
}
-bool MinidumpFileWriter::CopyStringToMDString(const char *str,
+bool MinidumpFileWriter::CopyStringToMDString(const char* str,
unsigned int length,
- TypedMDRVA<MDString> *mdstring) {
+ TypedMDRVA<MDString>* mdstring) {
bool result = true;
uint16_t out[2];
int out_idx = 0;
@@ -205,9 +205,9 @@
}
template <typename CharType>
-bool MinidumpFileWriter::WriteStringCore(const CharType *str,
+bool MinidumpFileWriter::WriteStringCore(const CharType* str,
unsigned int length,
- MDLocationDescriptor *location) {
+ MDLocationDescriptor* location) {
assert(str);
assert(location);
// Calculate the mdstring length by either limiting to |length| as passed in
@@ -240,18 +240,18 @@
return result;
}
-bool MinidumpFileWriter::WriteString(const wchar_t *str, unsigned int length,
- MDLocationDescriptor *location) {
+bool MinidumpFileWriter::WriteString(const wchar_t* str, unsigned int length,
+ MDLocationDescriptor* location) {
return WriteStringCore(str, length, location);
}
-bool MinidumpFileWriter::WriteString(const char *str, unsigned int length,
- MDLocationDescriptor *location) {
+bool MinidumpFileWriter::WriteString(const char* str, unsigned int length,
+ MDLocationDescriptor* location) {
return WriteStringCore(str, length, location);
}
-bool MinidumpFileWriter::WriteMemory(const void *src, size_t size,
- MDMemoryDescriptor *output) {
+bool MinidumpFileWriter::WriteMemory(const void* src, size_t size,
+ MDMemoryDescriptor* output) {
assert(src);
assert(output);
UntypedMDRVA mem(this);
@@ -307,7 +307,7 @@
return current_position;
}
-bool MinidumpFileWriter::Copy(MDRVA position, const void *src, ssize_t size) {
+bool MinidumpFileWriter::Copy(MDRVA position, const void* src, ssize_t size) {
assert(src);
assert(size);
assert(file_ != -1);
@@ -340,7 +340,7 @@
return position_ != MinidumpFileWriter::kInvalidMDRVA;
}
-bool UntypedMDRVA::Copy(MDRVA pos, const void *src, size_t size) {
+bool UntypedMDRVA::Copy(MDRVA pos, const void* src, size_t size) {
assert(src);
assert(size);
assert(pos + size <= position_ + size_);
diff --git a/src/client/minidump_file_writer.h b/src/client/minidump_file_writer.h
index ce32b6d..c66dc59 100644
--- a/src/client/minidump_file_writer.h
+++ b/src/client/minidump_file_writer.h
@@ -77,7 +77,7 @@
// Open |path| as the destination of the minidump data. If |path| already
// exists, then Open() will fail.
// Return true on success, or false on failure.
- bool Open(const char *path);
+ bool Open(const char* path);
// Sets the file descriptor |file| as the destination of the minidump data.
// Can be used as an alternative to Open() when a file descriptor is
@@ -98,20 +98,20 @@
// entire NULL terminated string. Copying will stop at the first NULL.
// |location| the allocated location
// Return true on success, or false on failure
- bool WriteString(const wchar_t *str, unsigned int length,
- MDLocationDescriptor *location);
+ bool WriteString(const wchar_t* str, unsigned int length,
+ MDLocationDescriptor* location);
// Same as above, except with |str| as a UTF-8 string
- bool WriteString(const char *str, unsigned int length,
- MDLocationDescriptor *location);
+ bool WriteString(const char* str, unsigned int length,
+ MDLocationDescriptor* location);
// Write |size| bytes starting at |src| into the current position.
// Return true on success and set |output| to position, or false on failure
- bool WriteMemory(const void *src, size_t size, MDMemoryDescriptor *output);
+ bool WriteMemory(const void* src, size_t size, MDMemoryDescriptor* output);
// Copies |size| bytes from |src| to |position|
// Return true on success, or false on failure
- bool Copy(MDRVA position, const void *src, ssize_t size);
+ bool Copy(MDRVA position, const void* src, ssize_t size);
// Return the current position for writing to the minidump
inline MDRVA position() const { return position_; }
@@ -141,21 +141,21 @@
// variant may need to create a MDString that has more characters than the
// source |str|, whereas the UTF-8 variant may coalesce characters to form
// a single UTF-16 character.
- bool CopyStringToMDString(const wchar_t *str, unsigned int length,
- TypedMDRVA<MDString> *mdstring);
- bool CopyStringToMDString(const char *str, unsigned int length,
- TypedMDRVA<MDString> *mdstring);
+ bool CopyStringToMDString(const wchar_t* str, unsigned int length,
+ TypedMDRVA<MDString>* mdstring);
+ bool CopyStringToMDString(const char* str, unsigned int length,
+ TypedMDRVA<MDString>* mdstring);
// The common templated code for writing a string
template <typename CharType>
- bool WriteStringCore(const CharType *str, unsigned int length,
- MDLocationDescriptor *location);
+ bool WriteStringCore(const CharType* str, unsigned int length,
+ MDLocationDescriptor* location);
};
// Represents an untyped allocated chunk
class UntypedMDRVA {
public:
- explicit UntypedMDRVA(MinidumpFileWriter *writer)
+ explicit UntypedMDRVA(MinidumpFileWriter* writer)
: writer_(writer),
position_(writer->position()),
size_(0) {}
@@ -179,16 +179,16 @@
// Copy |size| bytes starting at |src| into the minidump at |position|
// Return true on success, or false on failure
- bool Copy(MDRVA position, const void *src, size_t size);
+ bool Copy(MDRVA position, const void* src, size_t size);
// Copy |size| bytes from |src| to the current position
- inline bool Copy(const void *src, size_t size) {
+ inline bool Copy(const void* src, size_t size) {
return Copy(position_, src, size);
}
protected:
// Writer we associate with
- MinidumpFileWriter *writer_;
+ MinidumpFileWriter* writer_;
// Position of the start of the data
MDRVA position_;
@@ -206,7 +206,7 @@
class TypedMDRVA : public UntypedMDRVA {
public:
// Constructs an unallocated MDRVA
- explicit TypedMDRVA(MinidumpFileWriter *writer)
+ explicit TypedMDRVA(MinidumpFileWriter* writer)
: UntypedMDRVA(writer),
data_(),
allocation_state_(UNALLOCATED) {}
@@ -220,7 +220,7 @@
// Address of object data_ of MDType. This is not declared const as the
// typical usage will be to access the underlying |data_| object as to
// alter its contents.
- MDType *get() { return &data_; }
+ MDType* get() { return &data_; }
// Allocates minidump_size<MDType>::size() bytes.
// Must not call more than once.
@@ -245,12 +245,12 @@
// Copy |item| to |index|
// Must have been allocated using AllocateArray().
// Return true on success, or false on failure
- bool CopyIndex(unsigned int index, MDType *item);
+ bool CopyIndex(unsigned int index, MDType* item);
// Copy |size| bytes starting at |str| to |index|
// Must have been allocated using AllocateObjectAndArray().
// Return true on success, or false on failure
- bool CopyIndexAfterObject(unsigned int index, const void *src, size_t size);
+ bool CopyIndexAfterObject(unsigned int index, const void* src, size_t size);
// Write data_
bool Flush();
diff --git a/src/client/minidump_file_writer_unittest.cc b/src/client/minidump_file_writer_unittest.cc
index 256e337..16c407d 100644
--- a/src/client/minidump_file_writer_unittest.cc
+++ b/src/client/minidump_file_writer_unittest.cc
@@ -70,16 +70,16 @@
ArrayStructure array[0];
} ObjectAndArrayStructure;
-static bool WriteFile(const char *path) {
+static bool WriteFile(const char* path) {
MinidumpFileWriter writer;
if (writer.Open(path)) {
// Test a single structure
google_breakpad::TypedMDRVA<StringStructure> strings(&writer);
ASSERT_TRUE(strings.Allocate());
strings.get()->integer_value = 0xBEEF;
- const char *first = "First String";
+ const char* first = "First String";
ASSERT_TRUE(writer.WriteString(first, 0, &strings.get()->first_string));
- const wchar_t *second = L"Second String";
+ const wchar_t* second = L"Second String";
ASSERT_TRUE(writer.WriteString(second, 0, &strings.get()->second_string));
// Test an array structure
@@ -111,7 +111,7 @@
return writer.Close();
}
-static bool CompareFile(const char *path) {
+static bool CompareFile(const char* path) {
unsigned long expected[] = {
#if defined(__BIG_ENDIAN__)
0x0000beef, 0x0000001e, 0x00000018, 0x00000020, 0x00000038, 0x00000000,
@@ -146,13 +146,14 @@
};
size_t expected_byte_count = sizeof(expected);
int fd = open(path, O_RDONLY, 0600);
- void *buffer = malloc(expected_byte_count);
+ void* buffer = malloc(expected_byte_count);
ASSERT_NE(fd, -1);
ASSERT_TRUE(buffer);
ASSERT_EQ(read(fd, buffer, expected_byte_count),
static_cast<ssize_t>(expected_byte_count));
- char *b1, *b2;
+ char* b1;
+ char* b2;
b1 = reinterpret_cast<char*>(buffer);
b2 = reinterpret_cast<char*>(expected);
while (*b1 == *b2) {
@@ -167,13 +168,13 @@
}
static bool RunTests() {
- const char *path = "/tmp/minidump_file_writer_unittest.dmp";
+ const char* path = "/tmp/minidump_file_writer_unittest.dmp";
ASSERT_TRUE(WriteFile(path));
ASSERT_TRUE(CompareFile(path));
unlink(path);
return true;
}
-extern "C" int main(int argc, const char *argv[]) {
+extern "C" int main(int argc, const char* argv[]) {
return RunTests() ? 0 : 1;
}
diff --git a/src/client/solaris/handler/exception_handler.cc b/src/client/solaris/handler/exception_handler.cc
index 7fc8d25..c96683f 100644
--- a/src/client/solaris/handler/exception_handler.cc
+++ b/src/client/solaris/handler/exception_handler.cc
@@ -54,15 +54,15 @@
SIGBUS
};
-std::vector<ExceptionHandler*> *ExceptionHandler::handler_stack_ = NULL;
+std::vector<ExceptionHandler*>* ExceptionHandler::handler_stack_ = NULL;
int ExceptionHandler::handler_stack_index_ = 0;
pthread_mutex_t ExceptionHandler::handler_stack_mutex_ =
PTHREAD_MUTEX_INITIALIZER;
-ExceptionHandler::ExceptionHandler(const string &dump_path,
+ExceptionHandler::ExceptionHandler(const string& dump_path,
FilterCallback filter,
MinidumpCallback callback,
- void *callback_context,
+ void* callback_context,
bool install_handler)
: filter_(filter),
callback_(callback),
@@ -79,7 +79,7 @@
pthread_mutex_lock(&handler_stack_mutex_);
if (handler_stack_ == NULL)
- handler_stack_ = new std::vector<ExceptionHandler *>;
+ handler_stack_ = new std::vector<ExceptionHandler*>;
handler_stack_->push_back(this);
pthread_mutex_unlock(&handler_stack_mutex_);
}
@@ -92,7 +92,7 @@
handler_stack_->pop_back();
} else {
print_message1(2, "warning: removing Breakpad handler out of order\n");
- for (std::vector<ExceptionHandler *>::iterator iterator =
+ for (std::vector<ExceptionHandler*>::iterator iterator =
handler_stack_->begin();
iterator != handler_stack_->end();
++iterator) {
@@ -116,9 +116,9 @@
}
// static
-bool ExceptionHandler::WriteMinidump(const string &dump_path,
+bool ExceptionHandler::WriteMinidump(const string& dump_path,
MinidumpCallback callback,
- void *callback_context) {
+ void* callback_context) {
ExceptionHandler handler(dump_path, NULL, callback,
callback_context, false);
return handler.InternalWriteMinidump(0, 0, NULL);
@@ -166,7 +166,7 @@
// static
void ExceptionHandler::HandleException(int signo) {
-//void ExceptionHandler::HandleException(int signo, siginfo_t *sip, ucontext_t *sig_ctx) {
+//void ExceptionHandler::HandleException(int signo, siginfo_t* sip, ucontext_t* sig_ctx) {
// The context information about the signal is put on the stack of
// the signal handler frame as value parameter. For some reasons, the
// prototype of the handler doesn't declare this information as parameter, we
@@ -181,14 +181,14 @@
uintptr_t current_ebp = (uintptr_t)_getfp();
pthread_mutex_lock(&handler_stack_mutex_);
- ExceptionHandler *current_handler =
+ ExceptionHandler* current_handler =
handler_stack_->at(handler_stack_->size() - ++handler_stack_index_);
pthread_mutex_unlock(&handler_stack_mutex_);
// Restore original handler.
current_handler->TeardownHandler(signo);
- ucontext_t *sig_ctx = NULL;
+ ucontext_t* sig_ctx = NULL;
if (current_handler->InternalWriteMinidump(signo, current_ebp, &sig_ctx)) {
// if (current_handler->InternalWriteMinidump(signo, &sig_ctx)) {
// Fully handled this exception, safe to exit.
@@ -218,7 +218,7 @@
bool ExceptionHandler::InternalWriteMinidump(int signo,
uintptr_t sighandler_ebp,
- ucontext_t **sig_ctx) {
+ ucontext_t** sig_ctx) {
if (filter_ && !filter_(callback_context_))
return false;
diff --git a/src/client/solaris/handler/exception_handler.h b/src/client/solaris/handler/exception_handler.h
index 4d72485..cd6c85e 100644
--- a/src/client/solaris/handler/exception_handler.h
+++ b/src/client/solaris/handler/exception_handler.h
@@ -79,7 +79,7 @@
// attempting to write a minidump. If a FilterCallback returns false,
// Breakpad will immediately report the exception as unhandled without
// writing a minidump, allowing another handler the opportunity to handle it.
- typedef bool (*FilterCallback)(void *context);
+ typedef bool (*FilterCallback)(void* context);
// A callback function to run after the minidump has been written.
// minidump_id is a unique id for the dump, so the minidump
@@ -97,9 +97,9 @@
// should normally return the value of |succeeded|, or when they wish to
// not report an exception of handled, false. Callbacks will rarely want to
// return true directly (unless |succeeded| is true).
- typedef bool (*MinidumpCallback)(const char *dump_path,
- const char *minidump_id,
- void *context,
+ typedef bool (*MinidumpCallback)(const char* dump_path,
+ const char* minidump_id,
+ void* context,
bool succeeded);
// Creates a new ExceptionHandler instance to handle writing minidumps.
@@ -110,15 +110,15 @@
// If install_handler is true, then a minidump will be written whenever
// an unhandled exception occurs. If it is false, minidumps will only
// be written when WriteMinidump is called.
- ExceptionHandler(const string &dump_path,
+ ExceptionHandler(const string& dump_path,
FilterCallback filter, MinidumpCallback callback,
- void *callback_context,
+ void* callback_context,
bool install_handler);
~ExceptionHandler();
// Get and Set the minidump path.
string dump_path() const { return dump_path_; }
- void set_dump_path(const string &dump_path) {
+ void set_dump_path(const string& dump_path) {
dump_path_ = dump_path;
dump_path_c_ = dump_path_.c_str();
}
@@ -129,9 +129,9 @@
// Convenience form of WriteMinidump which does not require an
// ExceptionHandler instance.
- static bool WriteMinidump(const string &dump_path,
+ static bool WriteMinidump(const string& dump_path,
MinidumpCallback callback,
- void *callback_context);
+ void* callback_context);
private:
// Setup crash handler.
@@ -144,7 +144,7 @@
void TeardownAllHandlers();
// Runs the main loop for the exception handler thread.
- static void* ExceptionHandlerThreadMain(void *lpParameter);
+ static void* ExceptionHandlerThreadMain(void* lpParameter);
// Signal handler.
static void HandleException(int signo);
@@ -157,20 +157,20 @@
// for the second and third parameters if you are not calling
// this from a signal handler.
bool InternalWriteMinidump(int signo, uintptr_t sighandler_ebp,
- ucontext_t **sig_ctx);
+ ucontext_t** sig_ctx);
private:
// The callbacks before and after writing the dump file.
FilterCallback filter_;
MinidumpCallback callback_;
- void *callback_context_;
+ void* callback_context_;
// The directory in which a minidump will be written, set by the dump_path
// argument to the constructor, or set_dump_path.
string dump_path_;
// C style dump path. Keep this when setting dump path, since calling
// c_str() of std::string when crashing may not be safe.
- const char *dump_path_c_;
+ const char* dump_path_c_;
// True if the ExceptionHandler installed an unhandled exception filter
// when created (with an install_handler parameter set to true).
@@ -183,7 +183,7 @@
// The global exception handler stack. This is need becuase there may exist
// multiple ExceptionHandler instances in a process. Each will have itself
// registered in this stack.
- static std::vector<ExceptionHandler *> *handler_stack_;
+ static std::vector<ExceptionHandler*>* handler_stack_;
// The index of the handler that should handle the next exception.
static int handler_stack_index_;
static pthread_mutex_t handler_stack_mutex_;
@@ -192,8 +192,8 @@
MinidumpGenerator minidump_generator_;
// disallow copy ctor and operator=
- explicit ExceptionHandler(const ExceptionHandler &);
- void operator=(const ExceptionHandler &);
+ explicit ExceptionHandler(const ExceptionHandler&);
+ void operator=(const ExceptionHandler&);
};
} // namespace google_breakpad
diff --git a/src/client/solaris/handler/exception_handler_test.cc b/src/client/solaris/handler/exception_handler_test.cc
index 6bb8e18..4d2b33f 100644
--- a/src/client/solaris/handler/exception_handler_test.cc
+++ b/src/client/solaris/handler/exception_handler_test.cc
@@ -49,7 +49,7 @@
// Stack variable, used for debugging stack dumps.
int c = 0xcccccccc;
fprintf(stderr, "Thread trying to crash: %x\n", getpid());
- c = *reinterpret_cast<int *>(0x5);
+ c = *reinterpret_cast<int*>(0x5);
return c;
}
@@ -60,7 +60,7 @@
return b;
}
-static void *thread_crash(void *) {
+static void* thread_crash(void*) {
// Stack variable, used for debugging stack dumps.
int a = 0xaaaaaaaa;
sleep(3);
@@ -69,7 +69,7 @@
return NULL;
}
-static void *thread_main(void *) {
+static void* thread_main(void*) {
while (!should_exit)
sleep(1);
return NULL;
@@ -91,9 +91,9 @@
}
// Callback when minidump written.
-static bool MinidumpCallback(const char *dump_path,
- const char *minidump_id,
- void *context,
+static bool MinidumpCallback(const char* dump_path,
+ const char* minidump_id,
+ void* context,
bool succeeded) {
int index = reinterpret_cast<int>(context);
if (index == 0) {
@@ -104,7 +104,7 @@
return false;
}
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
int handler_index = 1;
ExceptionHandler handler_ignore(".", NULL, MinidumpCallback,
(void*)handler_index, true);
diff --git a/src/client/solaris/handler/minidump_generator.cc b/src/client/solaris/handler/minidump_generator.cc
index 7485025..5675666 100644
--- a/src/client/solaris/handler/minidump_generator.cc
+++ b/src/client/solaris/handler/minidump_generator.cc
@@ -50,7 +50,7 @@
// Argument for the writer function.
struct WriterArgument {
- MinidumpFileWriter *minidump_writer;
+ MinidumpFileWriter* minidump_writer;
// Pid of the lwp who called WriteMinidumpToFile
int requester_pid;
@@ -73,15 +73,15 @@
// User context when crash happens. Can be NULL if this is a requested dump.
// This is actually an out parameter, but it will be filled in at the start
// of the writer LWP.
- ucontext_t *sig_ctx;
+ ucontext_t* sig_ctx;
// Used to get information about the lwps.
- SolarisLwp *lwp_lister;
+ SolarisLwp* lwp_lister;
};
// Holding context information for the callback of finding the crashing lwp.
struct FindCrashLwpContext {
- const SolarisLwp *lwp_lister;
+ const SolarisLwp* lwp_lister;
uintptr_t crashing_stack_bottom;
int crashing_lwpid;
@@ -96,11 +96,11 @@
// It will compare the stack bottom of the provided lwp with the stack
// bottom of the crashed lwp, it they are eqaul, this lwp is the one
// who crashed.
-bool IsLwpCrashedCallback(lwpstatus_t *lsp, void *context) {
- FindCrashLwpContext *crashing_context =
- static_cast<FindCrashLwpContext *>(context);
- const SolarisLwp *lwp_lister = crashing_context->lwp_lister;
- const prgregset_t *gregs = &(lsp->pr_reg);
+bool IsLwpCrashedCallback(lwpstatus_t* lsp, void* context) {
+ FindCrashLwpContext* crashing_context =
+ static_cast<FindCrashLwpContext*>(context);
+ const SolarisLwp* lwp_lister = crashing_context->lwp_lister;
+ const prgregset_t* gregs = &(lsp->pr_reg);
#if TARGET_CPU_SPARC
uintptr_t last_ebp = (*gregs)[R_FP];
#elif TARGET_CPU_X86
@@ -121,7 +121,7 @@
// This is done based on stack bottom comparing.
int FindCrashingLwp(uintptr_t crashing_stack_bottom,
int requester_pid,
- const SolarisLwp *lwp_lister) {
+ const SolarisLwp* lwp_lister) {
FindCrashLwpContext context;
context.lwp_lister = lwp_lister;
context.crashing_stack_bottom = crashing_stack_bottom;
@@ -131,17 +131,17 @@
return context.crashing_lwpid;
}
-bool WriteLwpStack(const SolarisLwp *lwp_lister,
+bool WriteLwpStack(const SolarisLwp* lwp_lister,
uintptr_t last_esp,
- UntypedMDRVA *memory,
- MDMemoryDescriptor *loc) {
+ UntypedMDRVA* memory,
+ MDMemoryDescriptor* loc) {
uintptr_t stack_bottom = lwp_lister->GetLwpStackBottom(last_esp);
if (stack_bottom >= last_esp) {
int size = stack_bottom - last_esp;
if (size > 0) {
if (!memory->Allocate(size))
return false;
- memory->Copy(reinterpret_cast<void *>(last_esp), size);
+ memory->Copy(reinterpret_cast<void*>(last_esp), size);
loc->start_of_memory_range = last_esp;
loc->memory = memory->location();
}
@@ -151,7 +151,7 @@
}
#if TARGET_CPU_SPARC
-bool WriteContext(MDRawContextSPARC *context, ucontext_t *sig_ctx) {
+bool WriteContext(MDRawContextSPARC* context, ucontext_t* sig_ctx) {
assert(sig_ctx != NULL);
int* regs = sig_ctx->uc_mcontext.gregs;
context->context_flags = MD_CONTEXT_SPARC_FULL;
@@ -170,13 +170,13 @@
for ( int i = 1 ; i < 16; ++i ) {
context->g_r[i] = (uintptr_t)(sig_ctx->uc_mcontext.gregs[i + 3]);
}
- context->g_r[30] = (uintptr_t)(((struct frame *)context->g_r[14])->fr_savfp);
+ context->g_r[30] = (uintptr_t)(((struct frame*)context->g_r[14])->fr_savfp);
return true;
}
-bool WriteContext(MDRawContextSPARC *context, prgregset_t regs,
- prfpregset_t *fp_regs) {
+bool WriteContext(MDRawContextSPARC* context, prgregset_t regs,
+ prfpregset_t* fp_regs) {
if (!context || !regs)
return false;
@@ -195,8 +195,8 @@
return true;
}
#elif TARGET_CPU_X86
-bool WriteContext(MDRawContextX86 *context, prgregset_t regs,
- prfpregset_t *fp_regs) {
+bool WriteContext(MDRawContextX86* context, prgregset_t regs,
+ prfpregset_t* fp_regs) {
if (!context || !regs)
return false;
@@ -228,10 +228,10 @@
// signal. This makes the current stack not reliable, and our stack walker
// won't figure out the whole call stack for this. So we write the stack at the
// time of the crash into the minidump file, not the current stack.
-bool WriteCrashedLwpStream(MinidumpFileWriter *minidump_writer,
- const WriterArgument *writer_args,
- const lwpstatus_t *lsp,
- MDRawThread *lwp) {
+bool WriteCrashedLwpStream(MinidumpFileWriter* minidump_writer,
+ const WriterArgument* writer_args,
+ const lwpstatus_t* lsp,
+ MDRawThread* lwp) {
assert(writer_args->sig_ctx != NULL);
lwp->thread_id = lsp->pr_lwpid;
@@ -264,16 +264,16 @@
lwp->thread_context = context.location();
memset(context.get(), 0, sizeof(MDRawContextX86));
return WriteContext(context.get(),
- (int *)&writer_args->sig_ctx->uc_mcontext.gregs,
+ (int*)&writer_args->sig_ctx->uc_mcontext.gregs,
&writer_args->sig_ctx->uc_mcontext.fpregs);
#endif
}
-bool WriteLwpStream(MinidumpFileWriter *minidump_writer,
- const SolarisLwp *lwp_lister,
- const lwpstatus_t *lsp, MDRawThread *lwp) {
+bool WriteLwpStream(MinidumpFileWriter* minidump_writer,
+ const SolarisLwp* lwp_lister,
+ const lwpstatus_t* lsp, MDRawThread* lwp) {
prfpregset_t fp_regs = lsp->pr_fpreg;
- const prgregset_t *gregs = &(lsp->pr_reg);
+ const prgregset_t* gregs = &(lsp->pr_reg);
UntypedMDRVA memory(minidump_writer);
#if TARGET_CPU_SPARC
if (!WriteLwpStack(lwp_lister,
@@ -306,10 +306,10 @@
lwp->thread_context = context.location();
memset(context.get(), 0, sizeof(MDRawContextX86));
#endif /* TARGET_CPU_XXX */
- return WriteContext(context.get(), (int *)gregs, &fp_regs);
+ return WriteContext(context.get(), (int*)gregs, &fp_regs);
}
-bool WriteCPUInformation(MDRawSystemInfo *sys_info) {
+bool WriteCPUInformation(MDRawSystemInfo* sys_info) {
struct utsname uts;
char *major, *minor, *build;
@@ -337,8 +337,8 @@
return true;
}
-bool WriteOSInformation(MinidumpFileWriter *minidump_writer,
- MDRawSystemInfo *sys_info) {
+bool WriteOSInformation(MinidumpFileWriter* minidump_writer,
+ MDRawSystemInfo* sys_info) {
sys_info->platform_id = MD_OS_SOLARIS;
struct utsname uts;
@@ -346,7 +346,7 @@
char os_version[512];
size_t space_left = sizeof(os_version);
memset(os_version, 0, space_left);
- const char *os_info_table[] = {
+ const char* os_info_table[] = {
uts.sysname,
uts.release,
uts.version,
@@ -354,7 +354,7 @@
"OpenSolaris",
NULL
};
- for (const char **cur_os_info = os_info_table;
+ for (const char** cur_os_info = os_info_table;
*cur_os_info != NULL;
++cur_os_info) {
if (cur_os_info != os_info_table && space_left > 1) {
@@ -379,21 +379,21 @@
// Callback context for get writting lwp information.
struct LwpInfoCallbackCtx {
- MinidumpFileWriter *minidump_writer;
- const WriterArgument *writer_args;
- TypedMDRVA<MDRawThreadList> *list;
+ MinidumpFileWriter* minidump_writer;
+ const WriterArgument* writer_args;
+ TypedMDRVA<MDRawThreadList>* list;
int lwp_index;
};
-bool LwpInformationCallback(lwpstatus_t *lsp, void *context) {
+bool LwpInformationCallback(lwpstatus_t* lsp, void* context) {
bool success = true;
- LwpInfoCallbackCtx *callback_context =
- static_cast<LwpInfoCallbackCtx *>(context);
+ LwpInfoCallbackCtx* callback_context =
+ static_cast<LwpInfoCallbackCtx*>(context);
// The current lwp is the one to handle the crash. Ignore it.
if (lsp->pr_lwpid != pthread_self()) {
- LwpInfoCallbackCtx *callback_context =
- static_cast<LwpInfoCallbackCtx *>(context);
+ LwpInfoCallbackCtx* callback_context =
+ static_cast<LwpInfoCallbackCtx*>(context);
MDRawThread lwp;
memset(&lwp, 0, sizeof(MDRawThread));
@@ -417,11 +417,11 @@
return success;
}
-bool WriteLwpListStream(MinidumpFileWriter *minidump_writer,
- const WriterArgument *writer_args,
- MDRawDirectory *dir) {
+bool WriteLwpListStream(MinidumpFileWriter* minidump_writer,
+ const WriterArgument* writer_args,
+ MDRawDirectory* dir) {
// Get the lwp information.
- const SolarisLwp *lwp_lister = writer_args->lwp_lister;
+ const SolarisLwp* lwp_lister = writer_args->lwp_lister;
int lwp_count = lwp_lister->GetLwpCount();
if (lwp_count < 0)
return false;
@@ -444,14 +444,14 @@
return written == lwp_count;
}
-bool WriteCVRecord(MinidumpFileWriter *minidump_writer,
- MDRawModule *module,
- const char *module_path,
- char *realname) {
+bool WriteCVRecord(MinidumpFileWriter* minidump_writer,
+ MDRawModule* module,
+ const char* module_path,
+ char* realname) {
TypedMDRVA<MDCVInfoPDB70> cv(minidump_writer);
char path[PATH_MAX];
- const char *module_name = module_path ? module_path : "<Unknown>";
+ const char* module_name = module_path ? module_path : "<Unknown>";
snprintf(path, sizeof(path), "/proc/self/object/%s", module_name);
size_t module_name_length = strlen(realname);
@@ -461,7 +461,7 @@
return false;
module->cv_record = cv.location();
- MDCVInfoPDB70 *cv_ptr = cv.get();
+ MDCVInfoPDB70* cv_ptr = cv.get();
memset(cv_ptr, 0, sizeof(MDCVInfoPDB70));
cv_ptr->cv_signature = MD_CVINFOPDB70_SIGNATURE;
cv_ptr->age = 0;
@@ -489,15 +489,15 @@
}
struct ModuleInfoCallbackCtx {
- MinidumpFileWriter *minidump_writer;
- const WriterArgument *writer_args;
- TypedMDRVA<MDRawModuleList> *list;
+ MinidumpFileWriter* minidump_writer;
+ const WriterArgument* writer_args;
+ TypedMDRVA<MDRawModuleList>* list;
int module_index;
};
-bool ModuleInfoCallback(const ModuleInfo &module_info, void *context) {
- ModuleInfoCallbackCtx *callback_context =
- static_cast<ModuleInfoCallbackCtx *>(context);
+bool ModuleInfoCallback(const ModuleInfo& module_info, void* context) {
+ ModuleInfoCallbackCtx* callback_context =
+ static_cast<ModuleInfoCallbackCtx*>(context);
// Skip those modules without name, or those that are not modules.
if (strlen(module_info.name) == 0)
return true;
@@ -507,7 +507,7 @@
MDLocationDescriptor loc;
char path[PATH_MAX];
char buf[PATH_MAX];
- char *realname;
+ char* realname;
int count;
snprintf(path, sizeof (path), "/proc/self/path/%s", module_info.name);
@@ -535,9 +535,9 @@
return true;
}
-bool WriteModuleListStream(MinidumpFileWriter *minidump_writer,
- const WriterArgument *writer_args,
- MDRawDirectory *dir) {
+bool WriteModuleListStream(MinidumpFileWriter* minidump_writer,
+ const WriterArgument* writer_args,
+ MDRawDirectory* dir) {
TypedMDRVA<MDRawModuleList> list(minidump_writer);
int module_count = writer_args->lwp_lister->GetModuleCount();
@@ -558,9 +558,9 @@
return writer_args->lwp_lister->ListModules(&callback) == module_count;
}
-bool WriteSystemInfoStream(MinidumpFileWriter *minidump_writer,
- const WriterArgument *writer_args,
- MDRawDirectory *dir) {
+bool WriteSystemInfoStream(MinidumpFileWriter* minidump_writer,
+ const WriterArgument* writer_args,
+ MDRawDirectory* dir) {
TypedMDRVA<MDRawSystemInfo> sys_info(minidump_writer);
if (!sys_info.Allocate())
@@ -573,9 +573,9 @@
WriteOSInformation(minidump_writer, sys_info.get());
}
-bool WriteExceptionStream(MinidumpFileWriter *minidump_writer,
- const WriterArgument *writer_args,
- MDRawDirectory *dir) {
+bool WriteExceptionStream(MinidumpFileWriter* minidump_writer,
+ const WriterArgument* writer_args,
+ MDRawDirectory* dir) {
// This happenes when this is not a crash, but a requested dump.
if (writer_args->sig_ctx == NULL)
return false;
@@ -620,14 +620,14 @@
exception.get()->thread_context = context.location();
memset(context.get(), 0, sizeof(MDRawContextX86));
return WriteContext(context.get(),
- (int *)&writer_args->sig_ctx->uc_mcontext.gregs,
+ (int*)&writer_args->sig_ctx->uc_mcontext.gregs,
NULL);
#endif
}
-bool WriteMiscInfoStream(MinidumpFileWriter *minidump_writer,
- const WriterArgument *writer_args,
- MDRawDirectory *dir) {
+bool WriteMiscInfoStream(MinidumpFileWriter* minidump_writer,
+ const WriterArgument* writer_args,
+ MDRawDirectory* dir) {
TypedMDRVA<MDRawMiscInfo> info(minidump_writer);
if (!info.Allocate())
@@ -642,9 +642,9 @@
return true;
}
-bool WriteBreakpadInfoStream(MinidumpFileWriter *minidump_writer,
- const WriterArgument *writer_args,
- MDRawDirectory *dir) {
+bool WriteBreakpadInfoStream(MinidumpFileWriter* minidump_writer,
+ const WriterArgument* writer_args,
+ MDRawDirectory* dir) {
TypedMDRVA<MDRawBreakpadInfo> info(minidump_writer);
if (!info.Allocate())
@@ -662,16 +662,16 @@
class AutoLwpResumer {
public:
- AutoLwpResumer(SolarisLwp *lwp) : lwp_(lwp) {}
+ AutoLwpResumer(SolarisLwp* lwp) : lwp_(lwp) {}
~AutoLwpResumer() { lwp_->ControlAllLwps(false); }
private:
- SolarisLwp *lwp_;
+ SolarisLwp* lwp_;
};
// Prototype of writer functions.
-typedef bool (*WriteStreamFN)(MinidumpFileWriter *,
- const WriterArgument *,
- MDRawDirectory *);
+typedef bool (*WriteStreamFN)(MinidumpFileWriter*,
+ const WriterArgument*,
+ MDRawDirectory*);
// Function table to writer a full minidump.
const WriteStreamFN writers[] = {
@@ -684,9 +684,9 @@
};
// Will call each writer function in the writers table.
-//void* MinidumpGenerator::Write(void *argument) {
-void* Write(void *argument) {
- WriterArgument *writer_args = static_cast<WriterArgument *>(argument);
+//void* MinidumpGenerator::Write(void* argument) {
+void* Write(void* argument) {
+ WriterArgument* writer_args = static_cast<WriterArgument*>(argument);
if (!writer_args->lwp_lister->ControlAllLwps(true))
return NULL;
@@ -712,7 +712,7 @@
writer_args->crashed_lwpid = crashed_lwpid;
}
- MinidumpFileWriter *minidump_writer = writer_args->minidump_writer;
+ MinidumpFileWriter* minidump_writer = writer_args->minidump_writer;
TypedMDRVA<MDRawHeader> header(minidump_writer);
TypedMDRVA<MDRawDirectory> dir(minidump_writer);
if (!header.Allocate())
@@ -750,10 +750,10 @@
// Write minidump into file.
// It runs in a different thread from the crashing thread.
-bool MinidumpGenerator::WriteMinidumpToFile(const char *file_pathname,
+bool MinidumpGenerator::WriteMinidumpToFile(const char* file_pathname,
int signo,
uintptr_t sighandler_ebp,
- ucontext_t **sig_ctx) const {
+ ucontext_t** sig_ctx) const {
// The exception handler thread.
pthread_t handler_thread;
@@ -775,7 +775,7 @@
argument.sighandler_ebp = sighandler_ebp;
argument.sig_ctx = NULL;
- pthread_create(&handler_thread, NULL, Write, (void *)&argument);
+ pthread_create(&handler_thread, NULL, Write, (void*)&argument);
pthread_join(handler_thread, NULL);
return true;
}
diff --git a/src/client/solaris/handler/minidump_generator.h b/src/client/solaris/handler/minidump_generator.h
index 882f9e1..daa6fe0 100644
--- a/src/client/solaris/handler/minidump_generator.h
+++ b/src/client/solaris/handler/minidump_generator.h
@@ -48,10 +48,10 @@
//
class MinidumpGenerator {
// Callback run for writing lwp information in the process.
- friend bool LwpInformationCallback(lwpstatus_t *lsp, void *context);
+ friend bool LwpInformationCallback(lwpstatus_t* lsp, void* context);
// Callback run for writing module information in the process.
- friend bool ModuleInfoCallback(const ModuleInfo &module_info, void *context);
+ friend bool ModuleInfoCallback(const ModuleInfo& module_info, void* context);
public:
MinidumpGenerator();
@@ -59,10 +59,10 @@
~MinidumpGenerator();
// Write minidump.
- bool WriteMinidumpToFile(const char *file_pathname,
+ bool WriteMinidumpToFile(const char* file_pathname,
int signo,
uintptr_t sighandler_ebp,
- ucontext_t **sig_ctx) const;
+ ucontext_t** sig_ctx) const;
};
} // namespace google_breakpad
diff --git a/src/client/solaris/handler/minidump_test.cc b/src/client/solaris/handler/minidump_test.cc
index 33302d8..5f685ef 100644
--- a/src/client/solaris/handler/minidump_test.cc
+++ b/src/client/solaris/handler/minidump_test.cc
@@ -40,7 +40,7 @@
static bool doneWritingReport = false;
-static void *Reporter(void *) {
+static void* Reporter(void*) {
char buffer[PATH_MAX];
MinidumpGenerator md;
diff --git a/src/client/solaris/handler/solaris_lwp.cc b/src/client/solaris/handler/solaris_lwp.cc
index 0148997..cb6cc8a 100644
--- a/src/client/solaris/handler/solaris_lwp.cc
+++ b/src/client/solaris/handler/solaris_lwp.cc
@@ -69,10 +69,10 @@
};
// Convert from string to int.
-static bool LocalAtoi(char *s, int *r) {
+static bool LocalAtoi(char* s, int* r) {
assert(s != NULL);
assert(r != NULL);
- char *endptr = NULL;
+ char* endptr = NULL;
int ret = strtol(s, &endptr, 10);
if (endptr == s)
return false;
@@ -82,10 +82,10 @@
// Callback invoked for each mapped module.
// It uses the module's adderss range to validate the address.
-static bool AddressNotInModuleCallback(const ModuleInfo &module_info,
- void *context) {
- AddressValidatingContext *addr =
- reinterpret_cast<AddressValidatingContext *>(context);
+static bool AddressNotInModuleCallback(const ModuleInfo& module_info,
+ void* context) {
+ AddressValidatingContext* addr =
+ reinterpret_cast<AddressValidatingContext*>(context);
if (addr->is_mapped = ((module_info.start_addr > 0) &&
(addr->address >= module_info.start_addr) &&
(addr->address <= module_info.start_addr +
@@ -97,16 +97,16 @@
}
static int IterateLwpAll(int pid,
- CallbackParam<LwpidCallback> *callback_param) {
+ CallbackParam<LwpidCallback>* callback_param) {
char lwp_path[40];
- DIR *dir;
+ DIR* dir;
int count = 0;
snprintf(lwp_path, sizeof (lwp_path), "/proc/%d/lwp", (int)pid);
if ((dir = opendir(lwp_path)) == NULL)
return -1;
- struct dirent *entry = NULL;
+ struct dirent* entry = NULL;
while ((entry = readdir(dir)) != NULL) {
if ((strcmp(entry->d_name, ".") != 0) &&
(strcmp(entry->d_name, "..") != 0)) {
@@ -128,22 +128,22 @@
}
#if defined(__i386) && !defined(NO_FRAME_POINTER)
-void *GetNextFrame(void **last_ebp) {
- void *sp = *last_ebp;
+void* GetNextFrame(void** last_ebp) {
+ void* sp = *last_ebp;
if ((unsigned long)sp == (unsigned long)last_ebp)
return NULL;
- if ((unsigned long)sp & (sizeof(void *) - 1))
+ if ((unsigned long)sp & (sizeof(void*) - 1))
return NULL;
if ((unsigned long)sp - (unsigned long)last_ebp > 100000)
return NULL;
return sp;
}
#elif defined(__sparc)
-void *GetNextFrame(void *last_ebp) {
- return reinterpret_cast<struct frame *>(last_ebp)->fr_savfp;
+void* GetNextFrame(void* last_ebp) {
+ return reinterpret_cast<struct frame*>(last_ebp)->fr_savfp;
}
#else
-void *GetNextFrame(void **last_ebp) {
+void* GetNextFrame(void** last_ebp) {
return reinterpret_cast<void*>(last_ebp);
}
#endif
@@ -159,12 +159,12 @@
// Control the execution of the lwp.
// Suspend/Resume lwp based on the value of context.
-static bool ControlLwp(int lwpid, void *context) {
+static bool ControlLwp(int lwpid, void* context) {
// The current thread is the one to handle the crash. Ignore it.
if (lwpid != pthread_self()) {
int ctlfd;
char procname[PATH_MAX];
- bool suspend = *(bool *)context;
+ bool suspend = *(bool*)context;
// Open the /proc/$pid/lwp/$lwpid/lwpctl files
snprintf(procname, sizeof (procname), "/proc/self/lwp/%d/lwpctl", lwpid);
@@ -193,7 +193,7 @@
* prheader_t at the start (/proc/$pid/lstatus or /proc/$pid/lpsinfo).
* Return true on success.
*/
-static bool read_lfile(int pid, const char *lname, prheader_t *lhp) {
+static bool read_lfile(int pid, const char* lname, prheader_t* lhp) {
char lpath[PATH_MAX];
struct stat statb;
int fd;
@@ -242,14 +242,14 @@
}
int SolarisLwp::Lwp_iter_all(int pid,
- CallbackParam<LwpCallback> *callback_param) const {
- lwpstatus_t *Lsp;
- lwpstatus_t *sp;
+ CallbackParam<LwpCallback>* callback_param) const {
+ lwpstatus_t* Lsp;
+ lwpstatus_t* sp;
prheader_t lphp[HEADER_MAX];
prheader_t lhp[HEADER_MAX];
- prheader_t *Lphp = lphp;
- prheader_t *Lhp = lhp;
- lwpsinfo_t *Lpsp;
+ prheader_t* Lphp = lphp;
+ prheader_t* Lhp = lhp;
+ lwpsinfo_t* Lpsp;
long nstat;
long ninfo;
int rv = 0;
@@ -264,13 +264,13 @@
return -1;
}
- Lsp = (lwpstatus_t *)(uintptr_t)(Lhp + 1);
- Lpsp = (lwpsinfo_t *)(uintptr_t)(Lphp + 1);
+ Lsp = (lwpstatus_t*)(uintptr_t)(Lhp + 1);
+ Lpsp = (lwpsinfo_t*)(uintptr_t)(Lphp + 1);
for (ninfo = Lphp->pr_nent; ninfo != 0; --ninfo) {
if (Lpsp->pr_sname != 'Z') {
sp = Lsp;
- Lsp = (lwpstatus_t *)((uintptr_t)Lsp + Lhp->pr_entsize);
+ Lsp = (lwpstatus_t*)((uintptr_t)Lsp + Lhp->pr_entsize);
} else {
sp = NULL;
}
@@ -278,7 +278,7 @@
!(callback_param->call_back)(sp, callback_param->context))
break;
++rv;
- Lpsp = (lwpsinfo_t *)((uintptr_t)Lpsp + Lphp->pr_entsize);
+ Lpsp = (lwpsinfo_t*)((uintptr_t)Lpsp + Lphp->pr_entsize);
}
return rv;
@@ -298,12 +298,12 @@
}
int SolarisLwp::ListModules(
- CallbackParam<ModuleCallback> *callback_param) const {
- const char *maps_path = "/proc/self/map";
+ CallbackParam<ModuleCallback>* callback_param) const {
+ const char* maps_path = "/proc/self/map";
struct stat status;
int fd = 0, num;
prmap_t map_array[MAP_MAX];
- prmap_t *maps = map_array;
+ prmap_t* maps = map_array;
size_t size;
if ((fd = open(maps_path, O_RDONLY)) == -1) {
@@ -326,12 +326,12 @@
return -1;
}
- if (read(fd, (void *)maps, size) < 0) {
+ if (read(fd, (void*)maps, size) < 0) {
print_message2(2, "failed to read %d\n", fd);
return -1;
}
- prmap_t *_maps;
+ prmap_t* _maps;
int _num;
int module_count = 0;
@@ -345,7 +345,7 @@
*/
for (_num = 0, _maps = maps; _num < num; ++_num, ++_maps) {
ModuleInfo module;
- char *name = _maps->pr_mapname;
+ char* name = _maps->pr_mapname;
memset(&module, 0, sizeof (module));
module.start_addr = _maps->pr_vaddr;
@@ -403,7 +403,7 @@
// The Solaris stack looks like this:
// http://src.opensolaris.org/source/xref/onnv/onnv-gate/usr/src/lib/libproc/common/Pstack.c#81
bool SolarisLwp::FindSigContext(uintptr_t sighandler_ebp,
- ucontext_t **sig_ctx) {
+ ucontext_t** sig_ctx) {
uintptr_t previous_ebp;
uintptr_t sig_ebp;
const int MAX_STACK_DEPTH = 50;
@@ -416,7 +416,7 @@
*sig_ctx = reinterpret_cast<ucontext_t*>(sighandler_ebp + sizeof (struct frame));
uintptr_t sig_esp = (*sig_ctx)->uc_mcontext.gregs[REG_O6];
if (sig_esp < previous_ebp && sig_esp > sighandler_ebp)
- sig_ebp = (uintptr_t)(((struct frame *)sig_esp)->fr_savfp);
+ sig_ebp = (uintptr_t)(((struct frame*)sig_esp)->fr_savfp);
#elif TARGET_CPU_X86
previous_ebp = reinterpret_cast<uintptr_t>(GetNextFrame(
diff --git a/src/client/solaris/handler/solaris_lwp.h b/src/client/solaris/handler/solaris_lwp.h
index 0914cfc..afe352c 100644
--- a/src/client/solaris/handler/solaris_lwp.h
+++ b/src/client/solaris/handler/solaris_lwp.h
@@ -70,17 +70,17 @@
// A callback to run when getting a lwp in the process.
// Return true will go on to the next lwp while return false will stop the
// iteration.
-typedef bool (*LwpCallback)(lwpstatus_t* lsp, void *context);
+typedef bool (*LwpCallback)(lwpstatus_t* lsp, void* context);
// A callback to run when a new module is found in the process.
// Return true will go on to the next module while return false will stop the
// iteration.
-typedef bool (*ModuleCallback)(const ModuleInfo &module_info, void *context);
+typedef bool (*ModuleCallback)(const ModuleInfo& module_info, void* context);
// A callback to run when getting a lwpid in the process.
// Return true will go on to the next lwp while return false will stop the
// iteration.
-typedef bool (*LwpidCallback)(int lwpid, void *context);
+typedef bool (*LwpidCallback)(int lwpid, void* context);
// Holding the callback information.
template<class CallbackFunc>
@@ -88,12 +88,12 @@
// Callback function address.
CallbackFunc call_back;
// Callback context;
- void *context;
+ void* context;
CallbackParam() : call_back(NULL), context(NULL) {
}
- CallbackParam(CallbackFunc func, void *func_context) :
+ CallbackParam(CallbackFunc func, void* func_context) :
call_back(func), context(func_context) {
}
};
@@ -129,7 +129,7 @@
// Whenever there is a lwp found, the callback will be invoked to process
// the information.
// Return the callback return value or -1 on error.
- int Lwp_iter_all(int pid, CallbackParam<LwpCallback> *callback_param) const;
+ int Lwp_iter_all(int pid, CallbackParam<LwpCallback>* callback_param) const;
// Get the module count of the current process.
int GetModuleCount() const;
@@ -138,13 +138,13 @@
// Whenever a module is found, the callback will be invoked to process the
// information.
// Return how may modules are found.
- int ListModules(CallbackParam<ModuleCallback> *callback_param) const;
+ int ListModules(CallbackParam<ModuleCallback>* callback_param) const;
// Get the bottom of the stack from esp.
uintptr_t GetLwpStackBottom(uintptr_t current_esp) const;
// Finds a signal context on the stack given the ebp of our signal handler.
- bool FindSigContext(uintptr_t sighandler_ebp, ucontext_t **sig_ctx);
+ bool FindSigContext(uintptr_t sighandler_ebp, ucontext_t** sig_ctx);
private:
// Check if the address is a valid virtual address.
diff --git a/src/client/windows/handler/exception_handler.cc b/src/client/windows/handler/exception_handler.cc
index ad45b20..20d63a8 100644
--- a/src/client/windows/handler/exception_handler.cc
+++ b/src/client/windows/handler/exception_handler.cc
@@ -118,7 +118,7 @@
NULL); // custom_info - not used
}
-ExceptionHandler::ExceptionHandler(const wstring &dump_path,
+ExceptionHandler::ExceptionHandler(const wstring& dump_path,
FilterCallback filter,
MinidumpCallback callback,
void* callback_context,
@@ -383,7 +383,7 @@
// static
DWORD ExceptionHandler::ExceptionHandlerThreadMain(void* lpParameter) {
- ExceptionHandler* self = reinterpret_cast<ExceptionHandler *>(lpParameter);
+ ExceptionHandler* self = reinterpret_cast<ExceptionHandler*>(lpParameter);
assert(self);
assert(self->handler_start_semaphore_ != NULL);
assert(self->handler_finish_semaphore_ != NULL);
@@ -765,7 +765,7 @@
}
// static
-bool ExceptionHandler::WriteMinidump(const wstring &dump_path,
+bool ExceptionHandler::WriteMinidump(const wstring& dump_path,
MinidumpCallback callback,
void* callback_context,
MINIDUMP_TYPE dump_type) {
diff --git a/src/client/windows/handler/exception_handler.h b/src/client/windows/handler/exception_handler.h
index 11babe5..eb5adaa 100644
--- a/src/client/windows/handler/exception_handler.h
+++ b/src/client/windows/handler/exception_handler.h
@@ -218,7 +218,7 @@
// Get and set the minidump path.
wstring dump_path() const { return dump_path_; }
- void set_dump_path(const wstring &dump_path) {
+ void set_dump_path(const wstring& dump_path) {
dump_path_ = dump_path;
dump_path_c_ = dump_path_.c_str();
UpdateNextID(); // Necessary to put dump_path_ in next_minidump_path_.
@@ -237,7 +237,7 @@
// Convenience form of WriteMinidump which does not require an
// ExceptionHandler instance.
- static bool WriteMinidump(const wstring &dump_path,
+ static bool WriteMinidump(const wstring& dump_path,
MinidumpCallback callback, void* callback_context,
MINIDUMP_TYPE dump_type = MiniDumpNormal);
@@ -513,8 +513,8 @@
static volatile LONG instance_count_;
// disallow copy ctor and operator=
- explicit ExceptionHandler(const ExceptionHandler &);
- void operator=(const ExceptionHandler &);
+ explicit ExceptionHandler(const ExceptionHandler&);
+ void operator=(const ExceptionHandler&);
};
} // namespace google_breakpad
diff --git a/src/client/windows/sender/crash_report_sender.cc b/src/client/windows/sender/crash_report_sender.cc
index eb2b422..7fc6448 100644
--- a/src/client/windows/sender/crash_report_sender.cc
+++ b/src/client/windows/sender/crash_report_sender.cc
@@ -45,12 +45,12 @@
static const char kCheckpointSignature[] = "GBP1\n";
-CrashReportSender::CrashReportSender(const wstring &checkpoint_file)
+CrashReportSender::CrashReportSender(const wstring& checkpoint_file)
: checkpoint_file_(checkpoint_file),
max_reports_per_day_(-1),
last_sent_date_(-1),
reports_sent_(0) {
- FILE *fd;
+ FILE* fd;
if (OpenCheckpointFile(L"r", &fd) == 0) {
ReadCheckpoint(fd);
fclose(fd);
@@ -58,8 +58,8 @@
}
ReportResult CrashReportSender::SendCrashReport(
- const wstring &url, const map<wstring, wstring> ¶meters,
- const map<wstring, wstring> &files, wstring *report_code) {
+ const wstring& url, const map<wstring, wstring>& parameters,
+ const map<wstring, wstring>& files, wstring* report_code) {
int today = GetCurrentDate();
if (today == last_sent_date_ &&
max_reports_per_day_ != -1 &&
@@ -82,7 +82,7 @@
}
}
-void CrashReportSender::ReadCheckpoint(FILE *fd) {
+void CrashReportSender::ReadCheckpoint(FILE* fd) {
char buf[128];
if (!fgets(buf, sizeof(buf), fd) ||
strcmp(buf, kCheckpointSignature) != 0) {
@@ -108,7 +108,7 @@
++reports_sent_;
// Update the checkpoint file
- FILE *fd;
+ FILE* fd;
if (OpenCheckpointFile(L"w", &fd) == 0) {
fputs(kCheckpointSignature, fd);
fprintf(fd, "%d\n", last_sent_date_);
@@ -124,7 +124,7 @@
system_time.wDay;
}
-int CrashReportSender::OpenCheckpointFile(const wchar_t *mode, FILE **fd) {
+int CrashReportSender::OpenCheckpointFile(const wchar_t* mode, FILE** fd) {
if (checkpoint_file_.empty()) {
return ENOENT;
}
diff --git a/src/client/windows/sender/crash_report_sender.h b/src/client/windows/sender/crash_report_sender.h
index 7786cc6..e605585 100644
--- a/src/client/windows/sender/crash_report_sender.h
+++ b/src/client/windows/sender/crash_report_sender.h
@@ -65,7 +65,7 @@
// If checkpoint_file is non-empty, breakpad will persist crash report
// state to this file. A checkpoint file is required for
// set_max_reports_per_day() to function properly.
- explicit CrashReportSender(const wstring &checkpoint_file);
+ explicit CrashReportSender(const wstring& checkpoint_file);
~CrashReportSender() {}
// Sets the maximum number of crash reports that will be sent in a 24-hour
@@ -87,14 +87,14 @@
// the return value is RESULT_SUCCEEDED), a code uniquely identifying the
// report will be returned in report_code.
// (Otherwise, report_code will be unchanged.)
- ReportResult SendCrashReport(const wstring &url,
- const map<wstring, wstring> ¶meters,
- const map<wstring, wstring> &files,
- wstring *report_code);
+ ReportResult SendCrashReport(const wstring& url,
+ const map<wstring, wstring>& parameters,
+ const map<wstring, wstring>& files,
+ wstring* report_code);
private:
// Reads persistent state from a checkpoint file.
- void ReadCheckpoint(FILE *fd);
+ void ReadCheckpoint(FILE* fd);
// Called when a new report has been sent, to update the checkpoint state.
void ReportSent(int today);
@@ -104,7 +104,7 @@
// Opens the checkpoint file with the specified mode.
// Returns zero on success, or an error code on failure.
- int OpenCheckpointFile(const wchar_t *mode, FILE **fd);
+ int OpenCheckpointFile(const wchar_t* mode, FILE** fd);
wstring checkpoint_file_;
int max_reports_per_day_;
@@ -114,8 +114,8 @@
int reports_sent_;
// Disallow copy constructor and operator=
- explicit CrashReportSender(const CrashReportSender &);
- void operator=(const CrashReportSender &);
+ explicit CrashReportSender(const CrashReportSender&);
+ void operator=(const CrashReportSender&);
};
} // namespace google_breakpad
diff --git a/src/client/windows/unittests/dump_analysis.cc b/src/client/windows/unittests/dump_analysis.cc
index 53d4ddb..0bb8f6c 100644
--- a/src/client/windows/unittests/dump_analysis.cc
+++ b/src/client/windows/unittests/dump_analysis.cc
@@ -127,8 +127,8 @@
return ret ? memory_list_size : 0;
}
-bool DumpAnalysis::HasMemoryImpl(const void *addr_in, size_t structuresize,
- void **structure) const {
+bool DumpAnalysis::HasMemoryImpl(const void* addr_in, size_t structuresize,
+ void** structure) const {
uintptr_t address = reinterpret_cast<uintptr_t>(addr_in);
MINIDUMP_MEMORY_LIST* memory_list = NULL;
size_t memory_list_size = GetStream(MemoryListStream, &memory_list);
diff --git a/src/client/windows/unittests/exception_handler_death_test.cc b/src/client/windows/unittests/exception_handler_death_test.cc
index 5ef9e64..04034e8 100644
--- a/src/client/windows/unittests/exception_handler_death_test.cc
+++ b/src/client/windows/unittests/exception_handler_death_test.cc
@@ -52,7 +52,7 @@
const char kFailureIndicator[] = "failure";
// Utility function to test for a path's existence.
-BOOL DoesPathExist(const TCHAR *path_name);
+BOOL DoesPathExist(const TCHAR* path_name);
enum OutOfProcGuarantee {
OUT_OF_PROC_GUARANTEED,
@@ -92,7 +92,7 @@
CreateDirectory(temp_path_, NULL);
}
-BOOL DoesPathExist(const TCHAR *path_name) {
+BOOL DoesPathExist(const TCHAR* path_name) {
DWORD flags = GetFileAttributes(path_name);
if (flags == INVALID_FILE_ATTRIBUTES) {
return FALSE;
@@ -135,15 +135,15 @@
// Disable GTest SEH handler
testing::DisableExceptionHandlerInScope disable_exception_handler;
- int *i = NULL;
+ int* i = NULL;
ASSERT_DEATH((*i)++, kSuccessIndicator);
}
static bool gDumpCallbackCalled = false;
-void clientDumpCallback(void *dump_context,
- const google_breakpad::ClientInfo *client_info,
- const std::wstring *dump_path) {
+void clientDumpCallback(void* dump_context,
+ const google_breakpad::ClientInfo* client_info,
+ const std::wstring* dump_path) {
gDumpCallbackCalled = true;
}
@@ -152,7 +152,7 @@
scoped_ptr<google_breakpad::ExceptionHandler> exc;
if (out_of_proc_guarantee == OUT_OF_PROC_GUARANTEED) {
- google_breakpad::CrashGenerationClient *client =
+ google_breakpad::CrashGenerationClient* client =
new google_breakpad::CrashGenerationClient(kPipeName,
MiniDumpNormal,
NULL); // custom_info
@@ -184,7 +184,7 @@
// if it's not true we'll still get an error rather than the crash
// being expected.
ASSERT_TRUE(exc->IsOutOfProcess());
- int *i = NULL;
+ int* i = NULL;
printf("%d\n", (*i)++);
}
@@ -283,7 +283,7 @@
EXPECT_EXIT(DoCrashPureVirtualCall(), ::testing::ExitedWithCode(0), "");
}
-wstring find_minidump_in_directory(const wstring &directory) {
+wstring find_minidump_in_directory(const wstring& directory) {
wstring search_path = directory + L"\\*";
WIN32_FIND_DATA find_data;
HANDLE find_handle = FindFirstFileW(search_path.c_str(), &find_data);
diff --git a/src/client/windows/unittests/exception_handler_nesting_test.cc b/src/client/windows/unittests/exception_handler_nesting_test.cc
index 3ae1d7c..e24bd18 100644
--- a/src/client/windows/unittests/exception_handler_nesting_test.cc
+++ b/src/client/windows/unittests/exception_handler_nesting_test.cc
@@ -49,7 +49,7 @@
const char kCallbackReturnsTrue[] = "callback_returns_true";
const char kCallbackReturnsFalse[] = "callback_returns_false";
-bool DoesPathExist(const wchar_t *path_name) {
+bool DoesPathExist(const wchar_t* path_name) {
DWORD flags = GetFileAttributes(path_name);
if (flags == INVALID_FILE_ATTRIBUTES) {
return false;
@@ -128,12 +128,12 @@
}
-void DoCrash(const char *message) {
+void DoCrash(const char* message) {
if (message) {
fprintf(stderr, "%s", message);
fflush(stderr);
}
- int *i = NULL;
+ int* i = NULL;
(*i)++;
ASSERT_TRUE(false);
diff --git a/src/client/windows/unittests/exception_handler_test.cc b/src/client/windows/unittests/exception_handler_test.cc
index a4ce12a..51196ca 100644
--- a/src/client/windows/unittests/exception_handler_test.cc
+++ b/src/client/windows/unittests/exception_handler_test.cc
@@ -87,13 +87,13 @@
void DoCrashPureVirtualCall();
// Utility function to test for a path's existence.
- static BOOL DoesPathExist(const TCHAR *path_name);
+ static BOOL DoesPathExist(const TCHAR* path_name);
// Client callback.
static void ClientDumpCallback(
- void *dump_context,
- const google_breakpad::ClientInfo *client_info,
- const std::wstring *dump_path);
+ void* dump_context,
+ const google_breakpad::ClientInfo* client_info,
+ const std::wstring* dump_path);
static bool DumpCallback(const wchar_t* dump_path,
const wchar_t* minidump_id,
@@ -141,7 +141,7 @@
}
}
-BOOL ExceptionHandlerTest::DoesPathExist(const TCHAR *path_name) {
+BOOL ExceptionHandlerTest::DoesPathExist(const TCHAR* path_name) {
DWORD flags = GetFileAttributes(path_name);
if (flags == INVALID_FILE_ATTRIBUTES) {
return FALSE;
@@ -151,9 +151,9 @@
// static
void ExceptionHandlerTest::ClientDumpCallback(
- void *dump_context,
- const google_breakpad::ClientInfo *client_info,
- const wstring *dump_path) {
+ void* dump_context,
+ const google_breakpad::ClientInfo* client_info,
+ const wstring* dump_path) {
dump_file = *dump_path;
// Create the full dump file name from the dump path.
full_dump_file = dump_file.substr(0, dump_file.length() - 4) + L"-full.dmp";
@@ -174,7 +174,7 @@
}
void ExceptionHandlerTest::DoCrashInvalidParameter() {
- google_breakpad::ExceptionHandler *exc =
+ google_breakpad::ExceptionHandler* exc =
new google_breakpad::ExceptionHandler(
temp_path_, NULL, NULL, NULL,
google_breakpad::ExceptionHandler::HANDLER_INVALID_PARAMETER,
@@ -206,7 +206,7 @@
};
void ExceptionHandlerTest::DoCrashPureVirtualCall() {
- google_breakpad::ExceptionHandler *exc =
+ google_breakpad::ExceptionHandler* exc =
new google_breakpad::ExceptionHandler(
temp_path_, NULL, NULL, NULL,
google_breakpad::ExceptionHandler::HANDLER_PURECALL,
diff --git a/src/common/android/testing/pthread_fixes.h b/src/common/android/testing/pthread_fixes.h
index 20c1208..b0a3d82 100644
--- a/src/common/android/testing/pthread_fixes.h
+++ b/src/common/android/testing/pthread_fixes.h
@@ -80,7 +80,7 @@
return 0;
}
-int pthread_barrier_destroy(pthread_barrier_t *barrier) {
+int pthread_barrier_destroy(pthread_barrier_t* barrier) {
barrier->count = 0;
pthread_cond_destroy(&barrier->cond);
pthread_mutex_destroy(&barrier->mutex);
diff --git a/src/common/byte_cursor.h b/src/common/byte_cursor.h
index accd54e..28bb8e7 100644
--- a/src/common/byte_cursor.h
+++ b/src/common/byte_cursor.h
@@ -52,16 +52,16 @@
// A buffer holding a series of bytes.
struct ByteBuffer {
ByteBuffer() : start(0), end(0) { }
- ByteBuffer(const uint8_t *set_start, size_t set_size)
+ ByteBuffer(const uint8_t* set_start, size_t set_size)
: start(set_start), end(set_start + set_size) { }
~ByteBuffer() { };
// Equality operators. Useful in unit tests, and when we're using
// ByteBuffers to refer to regions of a larger buffer.
- bool operator==(const ByteBuffer &that) const {
+ bool operator==(const ByteBuffer& that) const {
return start == that.start && end == that.end;
}
- bool operator!=(const ByteBuffer &that) const {
+ bool operator!=(const ByteBuffer& that) const {
return start != that.start || end != that.end;
}
@@ -71,7 +71,8 @@
return end - start;
}
- const uint8_t *start, *end;
+ const uint8_t* start;
+ const uint8_t* end;
};
// A cursor pointing into a ByteBuffer that can parse numbers of various
@@ -82,8 +83,8 @@
public:
// Create a cursor reading bytes from the start of BUFFER. By default, the
// cursor reads multi-byte values in little-endian form.
- ByteCursor(const ByteBuffer *buffer, bool big_endian = false)
- : buffer_(buffer), here_(buffer->start),
+ ByteCursor(const ByteBuffer* buffer, bool big_endian = false)
+ : buffer_(buffer), here_(buffer->start),
big_endian_(big_endian), complete_(true) { }
// Accessor and setter for this cursor's endianness flag.
@@ -92,8 +93,8 @@
// Accessor and setter for this cursor's current position. The setter
// returns a reference to this cursor.
- const uint8_t *here() const { return here_; }
- ByteCursor &set_here(const uint8_t *here) {
+ const uint8_t* here() const { return here_; }
+ ByteCursor& set_here(const uint8_t* here) {
assert(buffer_->start <= here && here <= buffer_->end);
here_ = here;
return *this;
@@ -116,7 +117,7 @@
// this cursor's complete_ flag, and store a dummy value in *RESULT.
// Return a reference to this cursor.
template<typename T>
- ByteCursor &Read(size_t size, bool is_signed, T *result) {
+ ByteCursor& Read(size_t size, bool is_signed, T* result) {
if (CheckAvailable(size)) {
T v = 0;
if (big_endian_) {
@@ -145,7 +146,7 @@
// read off the end of our buffer, clear this cursor's complete_ flag.
// Return a reference to this cursor.
template<typename T>
- ByteCursor &operator>>(T &result) {
+ ByteCursor& operator>>(T& result) {
bool T_is_signed = (T)-1 < 0;
return Read(sizeof(T), T_is_signed, &result);
}
@@ -154,7 +155,7 @@
// cursor to the end of them. If we read off the end of our buffer,
// clear this cursor's complete_ flag, and set *POINTER to NULL.
// Return a reference to this cursor.
- ByteCursor &Read(uint8_t *buffer, size_t size) {
+ ByteCursor& Read(uint8_t* buffer, size_t size) {
if (CheckAvailable(size)) {
memcpy(buffer, here_, size);
here_ += size;
@@ -166,11 +167,11 @@
// byte buffer does not contain a terminating zero, clear this cursor's
// complete_ flag, and set STR to the empty string. Return a reference to
// this cursor.
- ByteCursor &CString(string *str) {
- const uint8_t *end
- = static_cast<const uint8_t *>(memchr(here_, '\0', Available()));
+ ByteCursor& CString(string* str) {
+ const uint8_t* end
+ = static_cast<const uint8_t*>(memchr(here_, '\0', Available()));
if (end) {
- str->assign(reinterpret_cast<const char *>(here_), end - here_);
+ str->assign(reinterpret_cast<const char*>(here_), end - here_);
here_ = end + 1;
} else {
str->clear();
@@ -193,14 +194,14 @@
//
// - Otherwise, set *STR to a copy of those LIMIT bytes, and advance the
// cursor by LIMIT bytes.
- ByteCursor &CString(string *str, size_t limit) {
+ ByteCursor& CString(string* str, size_t limit) {
if (CheckAvailable(limit)) {
- const uint8_t *end
- = static_cast<const uint8_t *>(memchr(here_, '\0', limit));
+ const uint8_t* end
+ = static_cast<const uint8_t*>(memchr(here_, '\0', limit));
if (end)
- str->assign(reinterpret_cast<const char *>(here_), end - here_);
+ str->assign(reinterpret_cast<const char*>(here_), end - here_);
else
- str->assign(reinterpret_cast<const char *>(here_), limit);
+ str->assign(reinterpret_cast<const char*>(here_), limit);
here_ += limit;
} else {
str->clear();
@@ -213,7 +214,7 @@
// cursor. If we read off the end of our buffer, clear this cursor's
// complete_ flag, and set *POINTER to NULL. Return a reference to this
// cursor.
- ByteCursor &PointTo(const uint8_t **pointer, size_t size = 0) {
+ ByteCursor& PointTo(const uint8_t** pointer, size_t size = 0) {
if (CheckAvailable(size)) {
*pointer = here_;
here_ += size;
@@ -226,7 +227,7 @@
// Skip SIZE bytes at the cursor. If doing so would advance us off
// the end of our buffer, clear this cursor's complete_ flag, and
// set *POINTER to NULL. Return a reference to this cursor.
- ByteCursor &Skip(size_t size) {
+ ByteCursor& Skip(size_t size) {
if (CheckAvailable(size))
here_ += size;
return *this;
@@ -247,10 +248,10 @@
}
// The buffer we're reading bytes from.
- const ByteBuffer *buffer_;
+ const ByteBuffer* buffer_;
// The next byte within buffer_ that we'll read.
- const uint8_t *here_;
+ const uint8_t* here_;
// True if we should read numbers in big-endian form; false if we
// should read in little-endian form.
diff --git a/src/common/byte_cursor_unittest.cc b/src/common/byte_cursor_unittest.cc
index 06bfd89..45e6f2b 100644
--- a/src/common/byte_cursor_unittest.cc
+++ b/src/common/byte_cursor_unittest.cc
@@ -593,7 +593,7 @@
int32_t a;
// For some reason, G++ 4.4.1 complains:
// warning: array subscript is above array bounds
- // in ByteCursor::Read(size_t, bool, T *) as it inlines this call, but
+ // in ByteCursor::Read(size_t, bool, T*) as it inlines this call, but
// I'm not able to see how such a reference would occur.
EXPECT_TRUE(cursor >> a);
EXPECT_EQ(-380377902, a);
@@ -627,7 +627,7 @@
uint32_t a;
// For some reason, G++ 4.4.1 complains:
// warning: array subscript is above array bounds
- // in ByteCursor::Read(size_t, bool, T *) as it inlines this call, but
+ // in ByteCursor::Read(size_t, bool, T*) as it inlines this call, but
// I'm not able to see how such a reference would occur.
EXPECT_TRUE(cursor >> a);
EXPECT_EQ(0xe953e4d2, a);
@@ -718,10 +718,10 @@
ByteBuffer buffer(data, sizeof(data));
ByteCursor cursor(&buffer);
- const uint8_t *received1;
- const uint8_t *received2;
- const uint8_t *received3;
- const uint8_t *received4;
+ const uint8_t* received1;
+ const uint8_t* received2;
+ const uint8_t* received3;
+ const uint8_t* received4;
EXPECT_FALSE(cursor
.PointTo(&received1, 3)
.PointTo(&received2, 3)
diff --git a/src/common/dwarf/bytereader-inl.h b/src/common/dwarf/bytereader-inl.h
index 235d75e..448be23 100644
--- a/src/common/dwarf/bytereader-inl.h
+++ b/src/common/dwarf/bytereader-inl.h
@@ -36,11 +36,11 @@
namespace dwarf2reader {
-inline uint8_t ByteReader::ReadOneByte(const uint8_t *buffer) const {
+inline uint8_t ByteReader::ReadOneByte(const uint8_t* buffer) const {
return buffer[0];
}
-inline uint16_t ByteReader::ReadTwoBytes(const uint8_t *buffer) const {
+inline uint16_t ByteReader::ReadTwoBytes(const uint8_t* buffer) const {
const uint16_t buffer0 = buffer[0];
const uint16_t buffer1 = buffer[1];
if (endian_ == ENDIANNESS_LITTLE) {
@@ -61,7 +61,7 @@
}
}
-inline uint64_t ByteReader::ReadFourBytes(const uint8_t *buffer) const {
+inline uint64_t ByteReader::ReadFourBytes(const uint8_t* buffer) const {
const uint32_t buffer0 = buffer[0];
const uint32_t buffer1 = buffer[1];
const uint32_t buffer2 = buffer[2];
@@ -73,7 +73,7 @@
}
}
-inline uint64_t ByteReader::ReadEightBytes(const uint8_t *buffer) const {
+inline uint64_t ByteReader::ReadEightBytes(const uint8_t* buffer) const {
const uint64_t buffer0 = buffer[0];
const uint64_t buffer1 = buffer[1];
const uint64_t buffer2 = buffer[2];
@@ -95,7 +95,7 @@
// information, plus one bit saying whether the number continues or
// not.
-inline uint64_t ByteReader::ReadUnsignedLEB128(const uint8_t *buffer,
+inline uint64_t ByteReader::ReadUnsignedLEB128(const uint8_t* buffer,
size_t* len) const {
uint64_t result = 0;
size_t num_read = 0;
@@ -120,7 +120,7 @@
// Read a signed LEB128 number. These are like regular LEB128
// numbers, except the last byte may have a sign bit set.
-inline int64_t ByteReader::ReadSignedLEB128(const uint8_t *buffer,
+inline int64_t ByteReader::ReadSignedLEB128(const uint8_t* buffer,
size_t* len) const {
int64_t result = 0;
unsigned int shift = 0;
@@ -140,18 +140,18 @@
return result;
}
-inline uint64_t ByteReader::ReadOffset(const uint8_t *buffer) const {
+inline uint64_t ByteReader::ReadOffset(const uint8_t* buffer) const {
assert(this->offset_reader_);
return (this->*offset_reader_)(buffer);
}
-inline uint64_t ByteReader::ReadAddress(const uint8_t *buffer) const {
+inline uint64_t ByteReader::ReadAddress(const uint8_t* buffer) const {
assert(this->address_reader_);
return (this->*address_reader_)(buffer);
}
inline void ByteReader::SetCFIDataBase(uint64_t section_base,
- const uint8_t *buffer_base) {
+ const uint8_t* buffer_base) {
section_base_ = section_base;
buffer_base_ = buffer_base;
have_section_base_ = true;
diff --git a/src/common/dwarf/bytereader.cc b/src/common/dwarf/bytereader.cc
index 0b27dd5..ac5064a 100644
--- a/src/common/dwarf/bytereader.cc
+++ b/src/common/dwarf/bytereader.cc
@@ -63,7 +63,7 @@
}
}
-uint64_t ByteReader::ReadInitialLength(const uint8_t *start, size_t* len) {
+uint64_t ByteReader::ReadInitialLength(const uint8_t* start, size_t* len) {
const uint64_t initial_length = ReadFourBytes(start);
start += 4;
@@ -101,9 +101,9 @@
}
}
-uint64_t ByteReader::ReadEncodedPointer(const uint8_t *buffer,
+uint64_t ByteReader::ReadEncodedPointer(const uint8_t* buffer,
DwarfPointerEncoding encoding,
- size_t *len) const {
+ size_t* len) const {
// UsableEncoding doesn't approve of DW_EH_PE_omit, so we shouldn't
// see it here.
assert(encoding != DW_EH_PE_omit);
@@ -130,7 +130,7 @@
// Round up to the next boundary.
uint64_t aligned = (offset + AddressSize() - 1) & -AddressSize();
// Convert back to a pointer.
- const uint8_t *aligned_buffer = buffer_base_ + (aligned - skew);
+ const uint8_t* aligned_buffer = buffer_base_ + (aligned - skew);
// Finally, store the length and actually fetch the pointer.
*len = aligned_buffer - buffer + AddressSize();
return ReadAddress(aligned_buffer);
diff --git a/src/common/dwarf/bytereader.h b/src/common/dwarf/bytereader.h
index d0c3b96..5d7a9a7 100644
--- a/src/common/dwarf/bytereader.h
+++ b/src/common/dwarf/bytereader.h
@@ -62,11 +62,11 @@
// Read a single byte from BUFFER and return it as an unsigned 8 bit
// number.
- uint8_t ReadOneByte(const uint8_t *buffer) const;
+ uint8_t ReadOneByte(const uint8_t* buffer) const;
// Read two bytes from BUFFER and return them as an unsigned 16 bit
// number, using this ByteReader's endianness.
- uint16_t ReadTwoBytes(const uint8_t *buffer) const;
+ uint16_t ReadTwoBytes(const uint8_t* buffer) const;
// Read three bytes from BUFFER and return them as an unsigned 64 bit
// number, using this ByteReader's endianness. DWARF 5 uses this encoding
@@ -78,11 +78,11 @@
// a uint64_t so that it is compatible with ReadAddress and
// ReadOffset. The number it returns will never be outside the range
// of an unsigned 32 bit integer.
- uint64_t ReadFourBytes(const uint8_t *buffer) const;
+ uint64_t ReadFourBytes(const uint8_t* buffer) const;
// Read eight bytes from BUFFER and return them as an unsigned 64
// bit number, using this ByteReader's endianness.
- uint64_t ReadEightBytes(const uint8_t *buffer) const;
+ uint64_t ReadEightBytes(const uint8_t* buffer) const;
// Read an unsigned LEB128 (Little Endian Base 128) number from
// BUFFER and return it as an unsigned 64 bit integer. Set LEN to
@@ -101,7 +101,7 @@
// In other words, we break VALUE into groups of seven bits, put
// them in little-endian order, and then write them as eight-bit
// bytes with the high bit on all but the last.
- uint64_t ReadUnsignedLEB128(const uint8_t *buffer, size_t *len) const;
+ uint64_t ReadUnsignedLEB128(const uint8_t* buffer, size_t* len) const;
// Read a signed LEB128 number from BUFFER and return it as an
// signed 64 bit integer. Set LEN to the number of bytes read.
@@ -120,7 +120,7 @@
// In other words, we break VALUE into groups of seven bits, put
// them in little-endian order, and then write them as eight-bit
// bytes with the high bit on all but the last.
- int64_t ReadSignedLEB128(const uint8_t *buffer, size_t *len) const;
+ int64_t ReadSignedLEB128(const uint8_t* buffer, size_t* len) const;
// Indicate that addresses on this architecture are SIZE bytes long. SIZE
// must be either 4 or 8. (DWARF allows addresses to be any number of
@@ -143,7 +143,7 @@
// Read an address from BUFFER and return it as an unsigned 64 bit
// integer, respecting this ByteReader's endianness and address size. You
// must call SetAddressSize before calling this function.
- uint64_t ReadAddress(const uint8_t *buffer) const;
+ uint64_t ReadAddress(const uint8_t* buffer) const;
// DWARF actually defines two slightly different formats: 32-bit DWARF
// and 64-bit DWARF. This is *not* related to the size of registers or
@@ -180,14 +180,14 @@
// - The 32-bit value 0xffffffff, followed by a 64-bit byte count,
// indicating that the data whose length is being measured uses
// the 64-bit DWARF format.
- uint64_t ReadInitialLength(const uint8_t *start, size_t *len);
+ uint64_t ReadInitialLength(const uint8_t* start, size_t* len);
// Read an offset from BUFFER and return it as an unsigned 64 bit
// integer, respecting the ByteReader's endianness. In 32-bit DWARF, the
// offset is 4 bytes long; in 64-bit DWARF, the offset is eight bytes
// long. You must call ReadInitialLength or SetOffsetSize before calling
// this function; see the comments above for details.
- uint64_t ReadOffset(const uint8_t *buffer) const;
+ uint64_t ReadOffset(const uint8_t* buffer) const;
// Return the current offset size, in bytes.
// A return value of 4 indicates that we are reading 32-bit DWARF.
@@ -242,7 +242,7 @@
// is BUFFER_BASE. This allows us to find the address that a given
// byte in our buffer would have when loaded into the program the
// data describes. We need this to resolve DW_EH_PE_pcrel pointers.
- void SetCFIDataBase(uint64_t section_base, const uint8_t *buffer_base);
+ void SetCFIDataBase(uint64_t section_base, const uint8_t* buffer_base);
// Indicate that the base address of the program's ".text" section
// is TEXT_BASE. We need this to resolve DW_EH_PE_textrel pointers.
@@ -281,15 +281,15 @@
// base address this reader hasn't been given, so you should check
// with ValidEncoding and UsableEncoding first if you would rather
// die in a more helpful way.
- uint64_t ReadEncodedPointer(const uint8_t *buffer,
+ uint64_t ReadEncodedPointer(const uint8_t* buffer,
DwarfPointerEncoding encoding,
- size_t *len) const;
+ size_t* len) const;
Endianness GetEndianness() const;
private:
// Function pointer type for our address and offset readers.
- typedef uint64_t (ByteReader::*AddressReader)(const uint8_t *) const;
+ typedef uint64_t (ByteReader::*AddressReader)(const uint8_t*) const;
// Read an offset from BUFFER and return it as an unsigned 64 bit
// integer. DWARF2/3 define offsets as either 4 or 8 bytes,
@@ -312,7 +312,7 @@
bool have_section_base_, have_text_base_, have_data_base_;
bool have_function_base_;
uint64_t section_base_, text_base_, data_base_, function_base_;
- const uint8_t *buffer_base_;
+ const uint8_t* buffer_base_;
};
} // namespace dwarf2reader
diff --git a/src/common/dwarf/bytereader_unittest.cc b/src/common/dwarf/bytereader_unittest.cc
index e66062d..3d7924b 100644
--- a/src/common/dwarf/bytereader_unittest.cc
+++ b/src/common/dwarf/bytereader_unittest.cc
@@ -73,7 +73,7 @@
.LEB128(-0x4f337badf4483f83LL)
.D32(0xfec319c9);
ASSERT_TRUE(section.GetContents(&contents));
- const uint8_t *data = reinterpret_cast<const uint8_t *>(contents.data());
+ const uint8_t* data = reinterpret_cast<const uint8_t*>(contents.data());
EXPECT_EQ(0xc0U, reader.ReadOneByte(data));
EXPECT_EQ(0xcf0dU, reader.ReadTwoBytes(data + 1));
EXPECT_EQ(0x96fdd219U, reader.ReadFourBytes(data + 3));
diff --git a/src/common/dwarf/cfi_assembler.cc b/src/common/dwarf/cfi_assembler.cc
index 2dc2208..858fd56 100644
--- a/src/common/dwarf/cfi_assembler.cc
+++ b/src/common/dwarf/cfi_assembler.cc
@@ -41,11 +41,11 @@
using dwarf2reader::DwarfPointerEncoding;
-CFISection &CFISection::CIEHeader(uint64_t code_alignment_factor,
+CFISection& CFISection::CIEHeader(uint64_t code_alignment_factor,
int data_alignment_factor,
unsigned return_address_register,
uint8_t version,
- const string &augmentation,
+ const string& augmentation,
bool dwarf64,
uint8_t address_size,
uint8_t segment_size) {
@@ -78,7 +78,7 @@
return *this;
}
-CFISection &CFISection::FDEHeader(Label cie_pointer,
+CFISection& CFISection::FDEHeader(Label cie_pointer,
uint64_t initial_location,
uint64_t address_range,
bool dwarf64) {
@@ -113,7 +113,7 @@
return *this;
}
-CFISection &CFISection::FinishEntry() {
+CFISection& CFISection::FinishEntry() {
assert(entry_length_);
Align(address_size_, dwarf2reader::DW_CFA_nop);
entry_length_->length = Here() - entry_length_->start;
@@ -123,9 +123,9 @@
return *this;
}
-CFISection &CFISection::EncodedPointer(uint64_t address,
+CFISection& CFISection::EncodedPointer(uint64_t address,
DwarfPointerEncoding encoding,
- const EncodedPointerBases &bases) {
+ const EncodedPointerBases& bases) {
// Omitted data is extremely easy to emit.
if (encoding == dwarf2reader::DW_EH_PE_omit)
return *this;
diff --git a/src/common/dwarf/cfi_assembler.h b/src/common/dwarf/cfi_assembler.h
index bd7354d..d60ecc9 100644
--- a/src/common/dwarf/cfi_assembler.h
+++ b/src/common/dwarf/cfi_assembler.h
@@ -120,7 +120,7 @@
// Use the addresses in BASES as the base addresses for encoded
// pointers in subsequent calls to FDEHeader or EncodedPointer.
// This function makes a copy of BASES.
- void SetEncodedPointerBases(const EncodedPointerBases &bases) {
+ void SetEncodedPointerBases(const EncodedPointerBases& bases) {
encoded_pointer_bases_ = bases;
}
@@ -133,11 +133,11 @@
// Before calling this function, you will typically want to use Mark
// or Here to make a label to pass to FDEHeader that refers to this
// CIE's position in the section.
- CFISection &CIEHeader(uint64_t code_alignment_factor,
+ CFISection& CIEHeader(uint64_t code_alignment_factor,
int data_alignment_factor,
unsigned return_address_register,
uint8_t version = 3,
- const string &augmentation = "",
+ const string& augmentation = "",
bool dwarf64 = false,
uint8_t address_size = 8,
uint8_t segment_size = 0);
@@ -152,7 +152,7 @@
// 0xffffff00 bytes. (The "initial length" is always a 32-bit
// value.) Nor does it support .debug_frame sections longer than
// 0xffffff00 bytes.
- CFISection &FDEHeader(Label cie_pointer,
+ CFISection& FDEHeader(Label cie_pointer,
uint64_t initial_location,
uint64_t address_range,
bool dwarf64 = false);
@@ -161,11 +161,11 @@
// started, after padding with DW_CFA_nops for alignment. This
// defines the label representing the entry's length, cited in the
// entry's header. Return a reference to this section.
- CFISection &FinishEntry();
+ CFISection& FinishEntry();
// Append the contents of BLOCK as a DW_FORM_block value: an
// unsigned LEB128 length, followed by that many bytes of data.
- CFISection &Block(const string &block) {
+ CFISection& Block(const string& block) {
ULEB128(block.size());
Append(block);
return *this;
@@ -173,11 +173,11 @@
// Append ADDRESS to this section, in the appropriate size and
// endianness. Return a reference to this section.
- CFISection &Address(uint64_t address) {
+ CFISection& Address(uint64_t address) {
Section::Append(endianness(), address_size_, address);
return *this;
}
- CFISection &Address(Label address) {
+ CFISection& Address(Label address) {
Section::Append(endianness(), address_size_, address);
return *this;
}
@@ -191,26 +191,26 @@
//
// (C++ doesn't let me use default arguments here, because I want to
// refer to members of *this in the default argument expression.)
- CFISection &EncodedPointer(uint64_t address) {
+ CFISection& EncodedPointer(uint64_t address) {
return EncodedPointer(address, pointer_encoding_, encoded_pointer_bases_);
}
- CFISection &EncodedPointer(uint64_t address, DwarfPointerEncoding encoding) {
+ CFISection& EncodedPointer(uint64_t address, DwarfPointerEncoding encoding) {
return EncodedPointer(address, encoding, encoded_pointer_bases_);
}
- CFISection &EncodedPointer(uint64_t address, DwarfPointerEncoding encoding,
- const EncodedPointerBases &bases);
+ CFISection& EncodedPointer(uint64_t address, DwarfPointerEncoding encoding,
+ const EncodedPointerBases& bases);
// Restate some member functions, to keep chaining working nicely.
- CFISection &Mark(Label *label) { Section::Mark(label); return *this; }
- CFISection &D8(uint8_t v) { Section::D8(v); return *this; }
- CFISection &D16(uint16_t v) { Section::D16(v); return *this; }
- CFISection &D16(Label v) { Section::D16(v); return *this; }
- CFISection &D32(uint32_t v) { Section::D32(v); return *this; }
- CFISection &D32(const Label &v) { Section::D32(v); return *this; }
- CFISection &D64(uint64_t v) { Section::D64(v); return *this; }
- CFISection &D64(const Label &v) { Section::D64(v); return *this; }
- CFISection &LEB128(long long v) { Section::LEB128(v); return *this; }
- CFISection &ULEB128(uint64_t v) { Section::ULEB128(v); return *this; }
+ CFISection& Mark(Label* label) { Section::Mark(label); return *this; }
+ CFISection& D8(uint8_t v) { Section::D8(v); return *this; }
+ CFISection& D16(uint16_t v) { Section::D16(v); return *this; }
+ CFISection& D16(Label v) { Section::D16(v); return *this; }
+ CFISection& D32(uint32_t v) { Section::D32(v); return *this; }
+ CFISection& D32(const Label& v) { Section::D32(v); return *this; }
+ CFISection& D64(uint64_t v) { Section::D64(v); return *this; }
+ CFISection& D64(const Label& v) { Section::D64(v); return *this; }
+ CFISection& LEB128(long long v) { Section::LEB128(v); return *this; }
+ CFISection& ULEB128(uint64_t v) { Section::ULEB128(v); return *this; }
private:
// A length value that we've appended to the section, but is not yet
diff --git a/src/common/dwarf/dwarf2diehandler.cc b/src/common/dwarf/dwarf2diehandler.cc
index 6384501..f5a0683 100644
--- a/src/common/dwarf/dwarf2diehandler.cc
+++ b/src/common/dwarf/dwarf2diehandler.cc
@@ -43,7 +43,7 @@
DIEDispatcher::~DIEDispatcher() {
while (!die_handlers_.empty()) {
- HandlerStack &entry = die_handlers_.top();
+ HandlerStack& entry = die_handlers_.top();
if (entry.handler_ != root_handler_)
delete entry.handler_;
die_handlers_.pop();
@@ -60,7 +60,7 @@
bool DIEDispatcher::StartDIE(uint64_t offset, enum DwarfTag tag) {
// The stack entry for the parent of this DIE, if there is one.
- HandlerStack *parent = die_handlers_.empty() ? NULL : &die_handlers_.top();
+ HandlerStack* parent = die_handlers_.empty() ? NULL : &die_handlers_.top();
// Does this call indicate that we're done receiving the parent's
// attributes' values? If so, call its EndAttributes member function.
@@ -78,7 +78,7 @@
}
// Find a handler for this DIE.
- DIEHandler *handler;
+ DIEHandler* handler;
if (parent) {
if (parent->handler_)
// Ask the parent to find a handler.
@@ -115,7 +115,7 @@
void DIEDispatcher::EndDIE(uint64_t offset) {
assert(!die_handlers_.empty());
- HandlerStack *entry = &die_handlers_.top();
+ HandlerStack* entry = &die_handlers_.top();
if (entry->handler_) {
// This entry had better be the handler for this DIE.
assert(entry->offset_ == offset);
@@ -139,7 +139,7 @@
enum DwarfAttribute attr,
enum DwarfForm form,
uint64_t data) {
- HandlerStack ¤t = die_handlers_.top();
+ HandlerStack& current = die_handlers_.top();
// This had better be an attribute of the DIE we were meant to handle.
assert(offset == current.offset_);
current.handler_->ProcessAttributeUnsigned(attr, form, data);
@@ -149,7 +149,7 @@
enum DwarfAttribute attr,
enum DwarfForm form,
int64_t data) {
- HandlerStack ¤t = die_handlers_.top();
+ HandlerStack& current = die_handlers_.top();
// This had better be an attribute of the DIE we were meant to handle.
assert(offset == current.offset_);
current.handler_->ProcessAttributeSigned(attr, form, data);
@@ -159,7 +159,7 @@
enum DwarfAttribute attr,
enum DwarfForm form,
uint64_t data) {
- HandlerStack ¤t = die_handlers_.top();
+ HandlerStack& current = die_handlers_.top();
// This had better be an attribute of the DIE we were meant to handle.
assert(offset == current.offset_);
current.handler_->ProcessAttributeReference(attr, form, data);
@@ -168,9 +168,9 @@
void DIEDispatcher::ProcessAttributeBuffer(uint64_t offset,
enum DwarfAttribute attr,
enum DwarfForm form,
- const uint8_t *data,
+ const uint8_t* data,
uint64_t len) {
- HandlerStack ¤t = die_handlers_.top();
+ HandlerStack& current = die_handlers_.top();
// This had better be an attribute of the DIE we were meant to handle.
assert(offset == current.offset_);
current.handler_->ProcessAttributeBuffer(attr, form, data, len);
@@ -180,7 +180,7 @@
enum DwarfAttribute attr,
enum DwarfForm form,
const string& data) {
- HandlerStack ¤t = die_handlers_.top();
+ HandlerStack& current = die_handlers_.top();
// This had better be an attribute of the DIE we were meant to handle.
assert(offset == current.offset_);
current.handler_->ProcessAttributeString(attr, form, data);
@@ -190,7 +190,7 @@
enum DwarfAttribute attr,
enum DwarfForm form,
uint64_t signature) {
- HandlerStack ¤t = die_handlers_.top();
+ HandlerStack& current = die_handlers_.top();
// This had better be an attribute of the DIE we were meant to handle.
assert(offset == current.offset_);
current.handler_->ProcessAttributeSignature(attr, form, signature);
diff --git a/src/common/dwarf/dwarf2diehandler.h b/src/common/dwarf/dwarf2diehandler.h
index 871ba43..028a6d1 100644
--- a/src/common/dwarf/dwarf2diehandler.h
+++ b/src/common/dwarf/dwarf2diehandler.h
@@ -208,7 +208,7 @@
uint64_t data) { }
virtual void ProcessAttributeBuffer(enum DwarfAttribute attr,
enum DwarfForm form,
- const uint8_t *data,
+ const uint8_t* data,
uint64_t len) { }
virtual void ProcessAttributeString(enum DwarfAttribute attr,
enum DwarfForm form,
@@ -244,7 +244,7 @@
// it is.
//
// The default definition skips all children.
- virtual DIEHandler *FindChildHandler(uint64_t offset, enum DwarfTag tag) {
+ virtual DIEHandler* FindChildHandler(uint64_t offset, enum DwarfTag tag) {
return NULL;
}
@@ -288,7 +288,7 @@
// Create a Dwarf2Handler which uses ROOT_HANDLER as the handler for
// the compilation unit's root die, as described for the DIEHandler
// class.
- DIEDispatcher(RootDIEHandler *root_handler) : root_handler_(root_handler) { }
+ DIEDispatcher(RootDIEHandler* root_handler) : root_handler_(root_handler) { }
// Destroying a DIEDispatcher destroys all active handler objects
// except the root handler.
~DIEDispatcher();
@@ -311,12 +311,12 @@
void ProcessAttributeBuffer(uint64_t offset,
enum DwarfAttribute attr,
enum DwarfForm form,
- const uint8_t *data,
+ const uint8_t* data,
uint64_t len);
void ProcessAttributeString(uint64_t offset,
enum DwarfAttribute attr,
enum DwarfForm form,
- const string &data);
+ const string& data);
void ProcessAttributeSignature(uint64_t offset,
enum DwarfAttribute attr,
enum DwarfForm form,
@@ -335,7 +335,7 @@
// The handler object interested in this DIE's attributes and
// children. If NULL, we're not interested in either.
- DIEHandler *handler_;
+ DIEHandler* handler_;
// Have we reported the end of this DIE's attributes to the handler?
bool reported_attributes_end_;
@@ -358,7 +358,7 @@
// The root handler. We don't push it on die_handlers_ until we
// actually get the StartDIE call for the root.
- RootDIEHandler *root_handler_;
+ RootDIEHandler* root_handler_;
};
} // namespace dwarf2reader
diff --git a/src/common/dwarf/dwarf2diehandler_unittest.cc b/src/common/dwarf/dwarf2diehandler_unittest.cc
index 01b7048..552c3d1 100644
--- a/src/common/dwarf/dwarf2diehandler_unittest.cc
+++ b/src/common/dwarf/dwarf2diehandler_unittest.cc
@@ -69,9 +69,9 @@
MOCK_METHOD3(ProcessAttributeReference,
void(DwarfAttribute, DwarfForm, uint64_t));
MOCK_METHOD4(ProcessAttributeBuffer,
- void(DwarfAttribute, DwarfForm, const uint8_t *, uint64_t));
+ void(DwarfAttribute, DwarfForm, const uint8_t*, uint64_t));
MOCK_METHOD3(ProcessAttributeString,
- void(DwarfAttribute, DwarfForm, const string &));
+ void(DwarfAttribute, DwarfForm, const string&));
MOCK_METHOD3(ProcessAttributeSignature,
void(DwarfAttribute, DwarfForm, uint64_t));
MOCK_METHOD0(EndAttributes, bool());
@@ -88,9 +88,9 @@
MOCK_METHOD3(ProcessAttributeReference,
void(DwarfAttribute, DwarfForm, uint64_t));
MOCK_METHOD4(ProcessAttributeBuffer,
- void(DwarfAttribute, DwarfForm, const uint8_t *, uint64_t));
+ void(DwarfAttribute, DwarfForm, const uint8_t*, uint64_t));
MOCK_METHOD3(ProcessAttributeString,
- void(DwarfAttribute, DwarfForm, const string &));
+ void(DwarfAttribute, DwarfForm, const string&));
MOCK_METHOD3(ProcessAttributeSignature,
void(DwarfAttribute, DwarfForm, uint64_t));
MOCK_METHOD0(EndAttributes, bool());
@@ -339,7 +339,7 @@
EXPECT_CALL(mock_root_handler,
FindChildHandler(0x97412be24875de9dLL,
(DwarfTag) 0x505a068b))
- .WillOnce(Return((DIEHandler *) NULL));
+ .WillOnce(Return((DIEHandler*) NULL));
// Third child DIE.
EXPECT_CALL(mock_root_handler,
diff --git a/src/common/dwarf/dwarf2reader.cc b/src/common/dwarf/dwarf2reader.cc
index ad82a5f..aca8367 100644
--- a/src/common/dwarf/dwarf2reader.cc
+++ b/src/common/dwarf/dwarf2reader.cc
@@ -122,9 +122,9 @@
// The only way to check whether we are reading over the end of the
// buffer would be to first compute the size of the leb128 data by
// reading it, then go back and read it again.
- const uint8_t *abbrev_start = iter->second.first +
+ const uint8_t* abbrev_start = iter->second.first +
header_.abbrev_offset;
- const uint8_t *abbrevptr = abbrev_start;
+ const uint8_t* abbrevptr = abbrev_start;
#ifndef NDEBUG
const uint64_t abbrev_length = iter->second.second - header_.abbrev_offset;
#endif
@@ -171,7 +171,7 @@
}
// Skips a single DIE's attributes.
-const uint8_t *CompilationUnit::SkipDIE(const uint8_t* start,
+const uint8_t* CompilationUnit::SkipDIE(const uint8_t* start,
const Abbrev& abbrev) {
for (AttributeList::const_iterator i = abbrev.attributes.begin();
i != abbrev.attributes.end();
@@ -182,7 +182,7 @@
}
// Skips a single attribute form's data.
-const uint8_t *CompilationUnit::SkipAttribute(const uint8_t *start,
+const uint8_t* CompilationUnit::SkipAttribute(const uint8_t* start,
enum DwarfForm form) {
size_t len;
@@ -219,7 +219,7 @@
case DW_FORM_ref_sig8:
return start + 8;
case DW_FORM_string:
- return start + strlen(reinterpret_cast<const char *>(start)) + 1;
+ return start + strlen(reinterpret_cast<const char*>(start)) + 1;
case DW_FORM_udata:
case DW_FORM_ref_udata:
case DW_FORM_strx:
@@ -311,7 +311,7 @@
// abbrevs, and an address size. DWARF5 adds a unit_type to distinguish
// between partial-, full-, skeleton-, split-, and type- compilation units.
void CompilationUnit::ReadHeader() {
- const uint8_t *headerptr = buffer_;
+ const uint8_t* headerptr = buffer_;
size_t initial_length_size;
assert(headerptr + 4 < buffer_ + buffer_length_);
@@ -455,8 +455,8 @@
// If one really wanted, you could merge SkipAttribute and
// ProcessAttribute
// This is all boring data manipulation and calling of the handler.
-const uint8_t *CompilationUnit::ProcessAttribute(
- uint64_t dieoffset, const uint8_t *start, enum DwarfAttribute attr,
+const uint8_t* CompilationUnit::ProcessAttribute(
+ uint64_t dieoffset, const uint8_t* start, enum DwarfAttribute attr,
enum DwarfForm form) {
size_t len;
@@ -490,7 +490,7 @@
reader_->ReadEightBytes(start));
return start + 8;
case DW_FORM_string: {
- const char *str = reinterpret_cast<const char *>(start);
+ const char* str = reinterpret_cast<const char*>(start);
ProcessAttributeString(dieoffset, attr, form, str);
return start + strlen(str) + 1;
}
@@ -588,7 +588,7 @@
const uint64_t offset = reader_->ReadOffset(start);
assert(string_buffer_ + offset < string_buffer_ + string_buffer_length_);
- const char *str = reinterpret_cast<const char *>(string_buffer_ + offset);
+ const char* str = reinterpret_cast<const char*>(string_buffer_ + offset);
ProcessAttributeString(dieoffset, attr, form, str);
return start + reader_->OffsetSize();
}
@@ -662,8 +662,8 @@
return NULL;
}
-const uint8_t *CompilationUnit::ProcessDIE(uint64_t dieoffset,
- const uint8_t *start,
+const uint8_t* CompilationUnit::ProcessDIE(uint64_t dieoffset,
+ const uint8_t* start,
const Abbrev& abbrev) {
for (AttributeList::const_iterator i = abbrev.attributes.begin();
i != abbrev.attributes.end();
@@ -684,12 +684,12 @@
}
void CompilationUnit::ProcessDIEs() {
- const uint8_t *dieptr = after_header_;
+ const uint8_t* dieptr = after_header_;
size_t len;
// lengthstart is the place the length field is based on.
// It is the point in the header after the initial length field
- const uint8_t *lengthstart = buffer_;
+ const uint8_t* lengthstart = buffer_;
// In 64 bit dwarf, the initial length is 12 bytes, because of the
// 0xffffffff at the start.
@@ -827,7 +827,7 @@
if (section_data != NULL)
sections->insert(std::make_pair(
base_name, std::make_pair(
- reinterpret_cast<const uint8_t *>(section_data),
+ reinterpret_cast<const uint8_t*>(section_data),
section_size)));
}
}
@@ -856,11 +856,11 @@
&string_buffer_size_);
version_ = byte_reader_.ReadFourBytes(
- reinterpret_cast<const uint8_t *>(cu_index_));
+ reinterpret_cast<const uint8_t*>(cu_index_));
if (version_ == 1) {
nslots_ = byte_reader_.ReadFourBytes(
- reinterpret_cast<const uint8_t *>(cu_index_)
+ reinterpret_cast<const uint8_t*>(cu_index_)
+ 3 * sizeof(uint32_t));
phash_ = cu_index_ + 4 * sizeof(uint32_t);
pindex_ = phash_ + nslots_ * sizeof(uint64_t);
@@ -870,11 +870,11 @@
}
} else if (version_ == 2) {
ncolumns_ = byte_reader_.ReadFourBytes(
- reinterpret_cast<const uint8_t *>(cu_index_) + sizeof(uint32_t));
+ reinterpret_cast<const uint8_t*>(cu_index_) + sizeof(uint32_t));
nunits_ = byte_reader_.ReadFourBytes(
- reinterpret_cast<const uint8_t *>(cu_index_) + 2 * sizeof(uint32_t));
+ reinterpret_cast<const uint8_t*>(cu_index_) + 2 * sizeof(uint32_t));
nslots_ = byte_reader_.ReadFourBytes(
- reinterpret_cast<const uint8_t *>(cu_index_) + 3 * sizeof(uint32_t));
+ reinterpret_cast<const uint8_t*>(cu_index_) + 3 * sizeof(uint32_t));
phash_ = cu_index_ + 4 * sizeof(uint32_t);
pindex_ = phash_ + nslots_ * sizeof(uint64_t);
offset_table_ = pindex_ + nslots_ * sizeof(uint32_t);
@@ -902,7 +902,7 @@
// can read a list of section indexes for the debug sections
// for the CU whose dwo_id we are looking for.
int index = byte_reader_.ReadFourBytes(
- reinterpret_cast<const uint8_t *>(pindex_)
+ reinterpret_cast<const uint8_t*>(pindex_)
+ slot * sizeof(uint32_t));
const char* shndx_list = shndx_pool_ + index * sizeof(uint32_t);
for (;;) {
@@ -911,7 +911,7 @@
return;
}
unsigned int shndx = byte_reader_.ReadFourBytes(
- reinterpret_cast<const uint8_t *>(shndx_list));
+ reinterpret_cast<const uint8_t*>(shndx_list));
shndx_list += sizeof(uint32_t);
if (shndx == 0)
break;
@@ -925,26 +925,26 @@
section_data = elf_reader_->GetSectionByIndex(shndx, §ion_size);
sections->insert(std::make_pair(
".debug_abbrev",
- std::make_pair(reinterpret_cast<const uint8_t *> (section_data),
+ std::make_pair(reinterpret_cast<const uint8_t*> (section_data),
section_size)));
} else if (!strncmp(section_name, ".debug_info", strlen(".debug_info"))) {
section_data = elf_reader_->GetSectionByIndex(shndx, §ion_size);
sections->insert(std::make_pair(
".debug_info",
- std::make_pair(reinterpret_cast<const uint8_t *> (section_data),
+ std::make_pair(reinterpret_cast<const uint8_t*> (section_data),
section_size)));
} else if (!strncmp(section_name, ".debug_str_offsets",
strlen(".debug_str_offsets"))) {
section_data = elf_reader_->GetSectionByIndex(shndx, §ion_size);
sections->insert(std::make_pair(
".debug_str_offsets",
- std::make_pair(reinterpret_cast<const uint8_t *> (section_data),
+ std::make_pair(reinterpret_cast<const uint8_t*> (section_data),
section_size)));
}
}
sections->insert(std::make_pair(
".debug_str",
- std::make_pair(reinterpret_cast<const uint8_t *> (string_buffer_),
+ std::make_pair(reinterpret_cast<const uint8_t*> (string_buffer_),
string_buffer_size_)));
} else if (version_ == 2) {
uint32_t index = LookupCUv2(dwo_id);
@@ -969,33 +969,33 @@
}
for (unsigned int col = 0u; col < ncolumns_; ++col) {
uint32_t section_id =
- byte_reader_.ReadFourBytes(reinterpret_cast<const uint8_t *>(id_row)
+ byte_reader_.ReadFourBytes(reinterpret_cast<const uint8_t*>(id_row)
+ col * sizeof(uint32_t));
uint32_t offset = byte_reader_.ReadFourBytes(
- reinterpret_cast<const uint8_t *>(offset_row)
+ reinterpret_cast<const uint8_t*>(offset_row)
+ col * sizeof(uint32_t));
uint32_t size = byte_reader_.ReadFourBytes(
- reinterpret_cast<const uint8_t *>(size_row) + col * sizeof(uint32_t));
+ reinterpret_cast<const uint8_t*>(size_row) + col * sizeof(uint32_t));
if (section_id == DW_SECT_ABBREV) {
sections->insert(std::make_pair(
".debug_abbrev",
- std::make_pair(reinterpret_cast<const uint8_t *> (abbrev_data_)
+ std::make_pair(reinterpret_cast<const uint8_t*> (abbrev_data_)
+ offset, size)));
} else if (section_id == DW_SECT_INFO) {
sections->insert(std::make_pair(
".debug_info",
- std::make_pair(reinterpret_cast<const uint8_t *> (info_data_)
+ std::make_pair(reinterpret_cast<const uint8_t*> (info_data_)
+ offset, size)));
} else if (section_id == DW_SECT_STR_OFFSETS) {
sections->insert(std::make_pair(
".debug_str_offsets",
- std::make_pair(reinterpret_cast<const uint8_t *> (str_offsets_data_)
+ std::make_pair(reinterpret_cast<const uint8_t*> (str_offsets_data_)
+ offset, size)));
}
}
sections->insert(std::make_pair(
".debug_str",
- std::make_pair(reinterpret_cast<const uint8_t *> (string_buffer_),
+ std::make_pair(reinterpret_cast<const uint8_t*> (string_buffer_),
string_buffer_size_)));
}
}
@@ -1003,14 +1003,14 @@
int DwpReader::LookupCU(uint64_t dwo_id) {
uint32_t slot = static_cast<uint32_t>(dwo_id) & (nslots_ - 1);
uint64_t probe = byte_reader_.ReadEightBytes(
- reinterpret_cast<const uint8_t *>(phash_) + slot * sizeof(uint64_t));
+ reinterpret_cast<const uint8_t*>(phash_) + slot * sizeof(uint64_t));
if (probe != 0 && probe != dwo_id) {
uint32_t secondary_hash =
(static_cast<uint32_t>(dwo_id >> 32) & (nslots_ - 1)) | 1;
do {
slot = (slot + secondary_hash) & (nslots_ - 1);
probe = byte_reader_.ReadEightBytes(
- reinterpret_cast<const uint8_t *>(phash_) + slot * sizeof(uint64_t));
+ reinterpret_cast<const uint8_t*>(phash_) + slot * sizeof(uint64_t));
} while (probe != 0 && probe != dwo_id);
}
if (probe == 0)
@@ -1021,24 +1021,24 @@
uint32_t DwpReader::LookupCUv2(uint64_t dwo_id) {
uint32_t slot = static_cast<uint32_t>(dwo_id) & (nslots_ - 1);
uint64_t probe = byte_reader_.ReadEightBytes(
- reinterpret_cast<const uint8_t *>(phash_) + slot * sizeof(uint64_t));
+ reinterpret_cast<const uint8_t*>(phash_) + slot * sizeof(uint64_t));
uint32_t index = byte_reader_.ReadFourBytes(
- reinterpret_cast<const uint8_t *>(pindex_) + slot * sizeof(uint32_t));
+ reinterpret_cast<const uint8_t*>(pindex_) + slot * sizeof(uint32_t));
if (index != 0 && probe != dwo_id) {
uint32_t secondary_hash =
(static_cast<uint32_t>(dwo_id >> 32) & (nslots_ - 1)) | 1;
do {
slot = (slot + secondary_hash) & (nslots_ - 1);
probe = byte_reader_.ReadEightBytes(
- reinterpret_cast<const uint8_t *>(phash_) + slot * sizeof(uint64_t));
+ reinterpret_cast<const uint8_t*>(phash_) + slot * sizeof(uint64_t));
index = byte_reader_.ReadFourBytes(
- reinterpret_cast<const uint8_t *>(pindex_) + slot * sizeof(uint32_t));
+ reinterpret_cast<const uint8_t*>(pindex_) + slot * sizeof(uint32_t));
} while (index != 0 && probe != dwo_id);
}
return index;
}
-LineInfo::LineInfo(const uint8_t *buffer, uint64_t buffer_length,
+LineInfo::LineInfo(const uint8_t* buffer, uint64_t buffer_length,
ByteReader* reader, const uint8_t* string_buffer,
size_t string_buffer_length,
const uint8_t* line_string_buffer,
@@ -1185,7 +1185,7 @@
// The header for a debug_line section is mildly complicated, because
// the line info is very tightly encoded.
void LineInfo::ReadHeader() {
- const uint8_t *lineptr = buffer_;
+ const uint8_t* lineptr = buffer_;
size_t initial_length_size;
const uint64_t initial_length
@@ -1331,12 +1331,12 @@
/* static */
bool LineInfo::ProcessOneOpcode(ByteReader* reader,
LineInfoHandler* handler,
- const struct LineInfoHeader &header,
- const uint8_t *start,
+ const struct LineInfoHeader& header,
+ const uint8_t* start,
struct LineStateMachine* lsm,
size_t* len,
uintptr pc,
- bool *lsm_passes_pc) {
+ bool* lsm_passes_pc) {
size_t oplen = 0;
size_t templen;
uint8_t opcode = reader->ReadOneByte(start);
@@ -1473,7 +1473,7 @@
}
break;
case DW_LNE_define_file: {
- const char *filename = reinterpret_cast<const char *>(start);
+ const char* filename = reinterpret_cast<const char*>(start);
templen = strlen(filename) + 1;
start += templen;
@@ -1520,7 +1520,7 @@
// lengthstart is the place the length field is based on.
// It is the point in the header after the initial length field
- const uint8_t *lengthstart = buffer_;
+ const uint8_t* lengthstart = buffer_;
// In 64 bit dwarf, the initial length is 12 bytes, because of the
// 0xffffffff at the start.
@@ -1529,7 +1529,7 @@
else
lengthstart += 4;
- const uint8_t *lineptr = after_header_;
+ const uint8_t* lineptr = after_header_;
lsm.Reset(header_.default_is_stmt);
// The LineInfoHandler interface expects each line's length along
@@ -1568,8 +1568,8 @@
after_header_ = lengthstart + header_.total_length;
}
-RangeListReader::RangeListReader(const uint8_t *buffer, uint64_t size,
- ByteReader *reader, RangeListHandler *handler)
+RangeListReader::RangeListReader(const uint8_t* buffer, uint64_t size,
+ ByteReader* reader, RangeListHandler* handler)
: buffer_(buffer), size_(size), reader_(reader), handler_(handler) { }
bool RangeListReader::ReadRangeList(uint64_t offset) {
@@ -1625,17 +1625,17 @@
// this rule. If REG is kCFARegister, then this rule describes how to compute
// the canonical frame address. Return what the HANDLER member function
// returned.
- virtual bool Handle(Handler *handler,
+ virtual bool Handle(Handler* handler,
uint64_t address, int reg) const = 0;
// Equality on rules. We use these to decide which rules we need
// to report after a DW_CFA_restore_state instruction.
- virtual bool operator==(const Rule &rhs) const = 0;
+ virtual bool operator==(const Rule& rhs) const = 0;
- bool operator!=(const Rule &rhs) const { return ! (*this == rhs); }
+ bool operator!=(const Rule& rhs) const { return ! (*this == rhs); }
// Return a pointer to a copy of this rule.
- virtual Rule *Copy() const = 0;
+ virtual Rule* Copy() const = 0;
// If this is a base+offset rule, change its base register to REG.
// Otherwise, do nothing. (Ugly, but required for DW_CFA_def_cfa_register.)
@@ -1651,16 +1651,16 @@
public:
UndefinedRule() { }
~UndefinedRule() { }
- bool Handle(Handler *handler, uint64_t address, int reg) const {
+ bool Handle(Handler* handler, uint64_t address, int reg) const {
return handler->UndefinedRule(address, reg);
}
- bool operator==(const Rule &rhs) const {
+ bool operator==(const Rule& rhs) const {
// dynamic_cast is allowed by the Google C++ Style Guide, if the use has
// been carefully considered; cheap RTTI-like workarounds are forbidden.
- const UndefinedRule *our_rhs = dynamic_cast<const UndefinedRule *>(&rhs);
+ const UndefinedRule* our_rhs = dynamic_cast<const UndefinedRule*>(&rhs);
return (our_rhs != NULL);
}
- Rule *Copy() const { return new UndefinedRule(*this); }
+ Rule* Copy() const { return new UndefinedRule(*this); }
};
// Rule: the register's value is the same as that it had in the caller.
@@ -1668,16 +1668,16 @@
public:
SameValueRule() { }
~SameValueRule() { }
- bool Handle(Handler *handler, uint64_t address, int reg) const {
+ bool Handle(Handler* handler, uint64_t address, int reg) const {
return handler->SameValueRule(address, reg);
}
- bool operator==(const Rule &rhs) const {
+ bool operator==(const Rule& rhs) const {
// dynamic_cast is allowed by the Google C++ Style Guide, if the use has
// been carefully considered; cheap RTTI-like workarounds are forbidden.
- const SameValueRule *our_rhs = dynamic_cast<const SameValueRule *>(&rhs);
+ const SameValueRule* our_rhs = dynamic_cast<const SameValueRule*>(&rhs);
return (our_rhs != NULL);
}
- Rule *Copy() const { return new SameValueRule(*this); }
+ Rule* Copy() const { return new SameValueRule(*this); }
};
// Rule: the register is saved at OFFSET from BASE_REGISTER. BASE_REGISTER
@@ -1687,18 +1687,18 @@
OffsetRule(int base_register, long offset)
: base_register_(base_register), offset_(offset) { }
~OffsetRule() { }
- bool Handle(Handler *handler, uint64_t address, int reg) const {
+ bool Handle(Handler* handler, uint64_t address, int reg) const {
return handler->OffsetRule(address, reg, base_register_, offset_);
}
- bool operator==(const Rule &rhs) const {
+ bool operator==(const Rule& rhs) const {
// dynamic_cast is allowed by the Google C++ Style Guide, if the use has
// been carefully considered; cheap RTTI-like workarounds are forbidden.
- const OffsetRule *our_rhs = dynamic_cast<const OffsetRule *>(&rhs);
+ const OffsetRule* our_rhs = dynamic_cast<const OffsetRule*>(&rhs);
return (our_rhs &&
base_register_ == our_rhs->base_register_ &&
offset_ == our_rhs->offset_);
}
- Rule *Copy() const { return new OffsetRule(*this); }
+ Rule* Copy() const { return new OffsetRule(*this); }
// We don't actually need SetBaseRegister or SetOffset here, since they
// are only ever applied to CFA rules, for DW_CFA_def_cfa_offset, and it
// doesn't make sense to use OffsetRule for computing the CFA: it
@@ -1716,18 +1716,18 @@
ValOffsetRule(int base_register, long offset)
: base_register_(base_register), offset_(offset) { }
~ValOffsetRule() { }
- bool Handle(Handler *handler, uint64_t address, int reg) const {
+ bool Handle(Handler* handler, uint64_t address, int reg) const {
return handler->ValOffsetRule(address, reg, base_register_, offset_);
}
- bool operator==(const Rule &rhs) const {
+ bool operator==(const Rule& rhs) const {
// dynamic_cast is allowed by the Google C++ Style Guide, if the use has
// been carefully considered; cheap RTTI-like workarounds are forbidden.
- const ValOffsetRule *our_rhs = dynamic_cast<const ValOffsetRule *>(&rhs);
+ const ValOffsetRule* our_rhs = dynamic_cast<const ValOffsetRule*>(&rhs);
return (our_rhs &&
base_register_ == our_rhs->base_register_ &&
offset_ == our_rhs->offset_);
}
- Rule *Copy() const { return new ValOffsetRule(*this); }
+ Rule* Copy() const { return new ValOffsetRule(*this); }
void SetBaseRegister(unsigned reg) { base_register_ = reg; }
void SetOffset(long long offset) { offset_ = offset; }
private:
@@ -1741,16 +1741,16 @@
explicit RegisterRule(int register_number)
: register_number_(register_number) { }
~RegisterRule() { }
- bool Handle(Handler *handler, uint64_t address, int reg) const {
+ bool Handle(Handler* handler, uint64_t address, int reg) const {
return handler->RegisterRule(address, reg, register_number_);
}
- bool operator==(const Rule &rhs) const {
+ bool operator==(const Rule& rhs) const {
// dynamic_cast is allowed by the Google C++ Style Guide, if the use has
// been carefully considered; cheap RTTI-like workarounds are forbidden.
- const RegisterRule *our_rhs = dynamic_cast<const RegisterRule *>(&rhs);
+ const RegisterRule* our_rhs = dynamic_cast<const RegisterRule*>(&rhs);
return (our_rhs && register_number_ == our_rhs->register_number_);
}
- Rule *Copy() const { return new RegisterRule(*this); }
+ Rule* Copy() const { return new RegisterRule(*this); }
private:
int register_number_;
};
@@ -1758,19 +1758,19 @@
// Rule: EXPRESSION evaluates to the address at which the register is saved.
class CallFrameInfo::ExpressionRule: public CallFrameInfo::Rule {
public:
- explicit ExpressionRule(const string &expression)
+ explicit ExpressionRule(const string& expression)
: expression_(expression) { }
~ExpressionRule() { }
- bool Handle(Handler *handler, uint64_t address, int reg) const {
+ bool Handle(Handler* handler, uint64_t address, int reg) const {
return handler->ExpressionRule(address, reg, expression_);
}
- bool operator==(const Rule &rhs) const {
+ bool operator==(const Rule& rhs) const {
// dynamic_cast is allowed by the Google C++ Style Guide, if the use has
// been carefully considered; cheap RTTI-like workarounds are forbidden.
- const ExpressionRule *our_rhs = dynamic_cast<const ExpressionRule *>(&rhs);
+ const ExpressionRule* our_rhs = dynamic_cast<const ExpressionRule*>(&rhs);
return (our_rhs && expression_ == our_rhs->expression_);
}
- Rule *Copy() const { return new ExpressionRule(*this); }
+ Rule* Copy() const { return new ExpressionRule(*this); }
private:
string expression_;
};
@@ -1778,20 +1778,20 @@
// Rule: EXPRESSION evaluates to the address at which the register is saved.
class CallFrameInfo::ValExpressionRule: public CallFrameInfo::Rule {
public:
- explicit ValExpressionRule(const string &expression)
+ explicit ValExpressionRule(const string& expression)
: expression_(expression) { }
~ValExpressionRule() { }
- bool Handle(Handler *handler, uint64_t address, int reg) const {
+ bool Handle(Handler* handler, uint64_t address, int reg) const {
return handler->ValExpressionRule(address, reg, expression_);
}
- bool operator==(const Rule &rhs) const {
+ bool operator==(const Rule& rhs) const {
// dynamic_cast is allowed by the Google C++ Style Guide, if the use has
// been carefully considered; cheap RTTI-like workarounds are forbidden.
- const ValExpressionRule *our_rhs =
- dynamic_cast<const ValExpressionRule *>(&rhs);
+ const ValExpressionRule* our_rhs =
+ dynamic_cast<const ValExpressionRule*>(&rhs);
return (our_rhs && expression_ == our_rhs->expression_);
}
- Rule *Copy() const { return new ValExpressionRule(*this); }
+ Rule* Copy() const { return new ValExpressionRule(*this); }
private:
string expression_;
};
@@ -1800,51 +1800,51 @@
class CallFrameInfo::RuleMap {
public:
RuleMap() : cfa_rule_(NULL) { }
- RuleMap(const RuleMap &rhs) : cfa_rule_(NULL) { *this = rhs; }
+ RuleMap(const RuleMap& rhs) : cfa_rule_(NULL) { *this = rhs; }
~RuleMap() { Clear(); }
- RuleMap &operator=(const RuleMap &rhs);
+ RuleMap& operator=(const RuleMap& rhs);
// Set the rule for computing the CFA to RULE. Take ownership of RULE.
- void SetCFARule(Rule *rule) { delete cfa_rule_; cfa_rule_ = rule; }
+ void SetCFARule(Rule* rule) { delete cfa_rule_; cfa_rule_ = rule; }
// Return the current CFA rule. Unlike RegisterRule, this RuleMap retains
// ownership of the rule. We use this for DW_CFA_def_cfa_offset and
// DW_CFA_def_cfa_register, and for detecting references to the CFA before
// a rule for it has been established.
- Rule *CFARule() const { return cfa_rule_; }
+ Rule* CFARule() const { return cfa_rule_; }
// Return the rule for REG, or NULL if there is none. The caller takes
// ownership of the result.
- Rule *RegisterRule(int reg) const;
+ Rule* RegisterRule(int reg) const;
// Set the rule for computing REG to RULE. Take ownership of RULE.
- void SetRegisterRule(int reg, Rule *rule);
+ void SetRegisterRule(int reg, Rule* rule);
// Make all the appropriate calls to HANDLER as if we were changing from
// this RuleMap to NEW_RULES at ADDRESS. We use this to implement
// DW_CFA_restore_state, where lots of rules can change simultaneously.
// Return true if all handlers returned true; otherwise, return false.
- bool HandleTransitionTo(Handler *handler, uint64_t address,
- const RuleMap &new_rules) const;
+ bool HandleTransitionTo(Handler* handler, uint64_t address,
+ const RuleMap& new_rules) const;
private:
// A map from register numbers to Rules.
- typedef std::map<int, Rule *> RuleByNumber;
+ typedef std::map<int, Rule*> RuleByNumber;
// Remove all register rules and clear cfa_rule_.
void Clear();
// The rule for computing the canonical frame address. This RuleMap owns
// this rule.
- Rule *cfa_rule_;
+ Rule* cfa_rule_;
// A map from register numbers to postfix expressions to recover
// their values. This RuleMap owns the Rules the map refers to.
RuleByNumber registers_;
};
-CallFrameInfo::RuleMap &CallFrameInfo::RuleMap::operator=(const RuleMap &rhs) {
+CallFrameInfo::RuleMap& CallFrameInfo::RuleMap::operator=(const RuleMap& rhs) {
Clear();
// Since each map owns the rules it refers to, assignment must copy them.
if (rhs.cfa_rule_) cfa_rule_ = rhs.cfa_rule_->Copy();
@@ -1854,7 +1854,7 @@
return *this;
}
-CallFrameInfo::Rule *CallFrameInfo::RuleMap::RegisterRule(int reg) const {
+CallFrameInfo::Rule* CallFrameInfo::RuleMap::RegisterRule(int reg) const {
assert(reg != Handler::kCFARegister);
RuleByNumber::const_iterator it = registers_.find(reg);
if (it != registers_.end())
@@ -1863,18 +1863,18 @@
return NULL;
}
-void CallFrameInfo::RuleMap::SetRegisterRule(int reg, Rule *rule) {
+void CallFrameInfo::RuleMap::SetRegisterRule(int reg, Rule* rule) {
assert(reg != Handler::kCFARegister);
assert(rule);
- Rule **slot = ®isters_[reg];
+ Rule** slot = ®isters_[reg];
delete *slot;
*slot = rule;
}
bool CallFrameInfo::RuleMap::HandleTransitionTo(
- Handler *handler,
+ Handler* handler,
uint64_t address,
- const RuleMap &new_rules) const {
+ const RuleMap& new_rules) const {
// Transition from cfa_rule_ to new_rules.cfa_rule_.
if (cfa_rule_ && new_rules.cfa_rule_) {
if (*cfa_rule_ != *new_rules.cfa_rule_ &&
@@ -1954,7 +1954,7 @@
public:
// Create a call frame information interpreter state with the given
// reporter, reader, handler, and initial call frame info address.
- State(ByteReader *reader, Handler *handler, Reporter *reporter,
+ State(ByteReader* reader, Handler* handler, Reporter* reporter,
uint64_t address)
: reader_(reader), handler_(handler), reporter_(reporter),
address_(address), entry_(NULL), cursor_(NULL) { }
@@ -1962,11 +1962,11 @@
// Interpret instructions from CIE, save the resulting rule set for
// DW_CFA_restore instructions, and return true. On error, report
// the problem to reporter_ and return false.
- bool InterpretCIE(const CIE &cie);
+ bool InterpretCIE(const CIE& cie);
// Interpret instructions from FDE, and return true. On error,
// report the problem to reporter_ and return false.
- bool InterpretFDE(const FDE &fde);
+ bool InterpretFDE(const FDE& fde);
private:
// The operands of a CFI instruction, for ParseOperands.
@@ -1996,7 +1996,7 @@
// '8' an eight-byte offset (OPERANDS->offset)
// 'e' a DW_FORM_block holding a (OPERANDS->expression)
// DWARF expression
- bool ParseOperands(const char *format, Operands *operands);
+ bool ParseOperands(const char* format, Operands* operands);
// Interpret one CFI instruction from STATE's instruction stream, update
// STATE, report any rule changes to handler_, and return true. On
@@ -2019,7 +2019,7 @@
// Specify that REG can be recovered using RULE, and return true. On
// failure, report and return false.
- bool DoRule(unsigned reg, Rule *rule);
+ bool DoRule(unsigned reg, Rule* rule);
// Specify that REG can be found at OFFSET from the CFA, and return true.
// On failure, report and return false. (Subroutine for DW_CFA_offset,
@@ -2047,23 +2047,23 @@
}
// For reading multi-byte values with the appropriate endianness.
- ByteReader *reader_;
+ ByteReader* reader_;
// The handler to which we should report the data we find.
- Handler *handler_;
+ Handler* handler_;
// For reporting problems in the info we're parsing.
- Reporter *reporter_;
+ Reporter* reporter_;
// The code address to which the next instruction in the stream applies.
uint64_t address_;
// The entry whose instructions we are currently processing. This is
// first a CIE, and then an FDE.
- const Entry *entry_;
+ const Entry* entry_;
// The next instruction to process.
- const uint8_t *cursor_;
+ const uint8_t* cursor_;
// The current set of rules.
RuleMap rules_;
@@ -2078,7 +2078,7 @@
std::stack<RuleMap> saved_rules_;
};
-bool CallFrameInfo::State::InterpretCIE(const CIE &cie) {
+bool CallFrameInfo::State::InterpretCIE(const CIE& cie) {
entry_ = &cie;
cursor_ = entry_->instructions;
while (cursor_ < entry_->end)
@@ -2090,7 +2090,7 @@
return true;
}
-bool CallFrameInfo::State::InterpretFDE(const FDE &fde) {
+bool CallFrameInfo::State::InterpretFDE(const FDE& fde) {
entry_ = &fde;
cursor_ = entry_->instructions;
while (cursor_ < entry_->end)
@@ -2099,10 +2099,10 @@
return true;
}
-bool CallFrameInfo::State::ParseOperands(const char *format,
- Operands *operands) {
+bool CallFrameInfo::State::ParseOperands(const char* format,
+ Operands* operands) {
size_t len;
- const char *operand;
+ const char* operand;
for (operand = format; *operand; operand++) {
size_t bytes_left = entry_->end - cursor_;
@@ -2161,7 +2161,7 @@
if (len > bytes_left || expression_length > bytes_left - len)
return ReportIncomplete();
cursor_ += len;
- operands->expression = string(reinterpret_cast<const char *>(cursor_),
+ operands->expression = string(reinterpret_cast<const char*>(cursor_),
expression_length);
cursor_ += expression_length;
break;
@@ -2176,7 +2176,7 @@
}
bool CallFrameInfo::State::DoInstruction() {
- CIE *cie = entry_->cie;
+ CIE* cie = entry_->cie;
Operands ops;
// Our entry's kind should have been set by now.
@@ -2266,7 +2266,7 @@
// Change the base register used to compute the CFA.
case DW_CFA_def_cfa_register: {
if (!ParseOperands("r", &ops)) return false;
- Rule *cfa_rule = rules_.CFARule();
+ Rule* cfa_rule = rules_.CFARule();
if (!cfa_rule) {
if (!DoDefCFA(ops.register_number, ops.offset)) {
reporter_->NoCFARule(entry_->offset, entry_->kind, CursorOffset());
@@ -2299,7 +2299,7 @@
case DW_CFA_def_cfa_expression: {
if (!ParseOperands("e", &ops))
return false;
- Rule *rule = new ValExpressionRule(ops.expression);
+ Rule* rule = new ValExpressionRule(ops.expression);
rules_.SetCFARule(rule);
if (!rule->Handle(handler_, address_,
Handler::kCFARegister))
@@ -2406,7 +2406,7 @@
CursorOffset());
return false;
}
- const RuleMap &new_rules = saved_rules_.top();
+ const RuleMap& new_rules = saved_rules_.top();
if (rules_.CFARule() && !new_rules.CFARule()) {
reporter_->ClearingCFARule(entry_->offset, entry_->kind,
CursorOffset());
@@ -2458,14 +2458,14 @@
}
bool CallFrameInfo::State::DoDefCFA(unsigned base_register, long offset) {
- Rule *rule = new ValOffsetRule(base_register, offset);
+ Rule* rule = new ValOffsetRule(base_register, offset);
rules_.SetCFARule(rule);
return rule->Handle(handler_, address_,
Handler::kCFARegister);
}
bool CallFrameInfo::State::DoDefCFAOffset(long offset) {
- Rule *cfa_rule = rules_.CFARule();
+ Rule* cfa_rule = rules_.CFARule();
if (!cfa_rule) {
reporter_->NoCFARule(entry_->offset, entry_->kind, CursorOffset());
return false;
@@ -2475,7 +2475,7 @@
Handler::kCFARegister);
}
-bool CallFrameInfo::State::DoRule(unsigned reg, Rule *rule) {
+bool CallFrameInfo::State::DoRule(unsigned reg, Rule* rule) {
rules_.SetRegisterRule(reg, rule);
return rule->Handle(handler_, address_, reg);
}
@@ -2504,7 +2504,7 @@
reporter_->RestoreInCIE(entry_->offset, CursorOffset());
return false;
}
- Rule *rule = cie_rules_.RegisterRule(reg);
+ Rule* rule = cie_rules_.RegisterRule(reg);
if (!rule) {
// This isn't really the right thing to do, but since CFI generally
// only mentions callee-saves registers, and GCC's convention for
@@ -2515,8 +2515,8 @@
return DoRule(reg, rule);
}
-bool CallFrameInfo::ReadEntryPrologue(const uint8_t *cursor, Entry *entry) {
- const uint8_t *buffer_end = buffer_ + buffer_length_;
+bool CallFrameInfo::ReadEntryPrologue(const uint8_t* cursor, Entry* entry) {
+ const uint8_t* buffer_end = buffer_ + buffer_length_;
// Initialize enough of ENTRY for use in error reporting.
entry->offset = cursor - buffer_;
@@ -2593,8 +2593,8 @@
return true;
}
-bool CallFrameInfo::ReadCIEFields(CIE *cie) {
- const uint8_t *cursor = cie->fields;
+bool CallFrameInfo::ReadCIEFields(CIE* cie) {
+ const uint8_t* cursor = cie->fields;
size_t len;
assert(cie->kind == kCIE);
@@ -2625,13 +2625,13 @@
return false;
}
- const uint8_t *augmentation_start = cursor;
- const uint8_t *augmentation_end =
- reinterpret_cast<const uint8_t *>(memchr(augmentation_start, '\0',
+ const uint8_t* augmentation_start = cursor;
+ const uint8_t* augmentation_end =
+ reinterpret_cast<const uint8_t*>(memchr(augmentation_start, '\0',
cie->end - augmentation_start));
if (! augmentation_end) return ReportIncomplete(cie);
cursor = augmentation_end;
- cie->augmentation = string(reinterpret_cast<const char *>(augmentation_start),
+ cie->augmentation = string(reinterpret_cast<const char*>(augmentation_start),
cursor - augmentation_start);
// Skip the terminating '\0'.
cursor++;
@@ -2692,9 +2692,9 @@
if (size_t(cie->end - cursor) < len + data_size)
return ReportIncomplete(cie);
cursor += len;
- const uint8_t *data = cursor;
+ const uint8_t* data = cursor;
cursor += data_size;
- const uint8_t *data_end = cursor;
+ const uint8_t* data_end = cursor;
cie->has_z_lsda = false;
cie->has_z_personality = false;
@@ -2785,8 +2785,8 @@
return true;
}
-bool CallFrameInfo::ReadFDEFields(FDE *fde) {
- const uint8_t *cursor = fde->fields;
+bool CallFrameInfo::ReadFDEFields(FDE* fde) {
+ const uint8_t* cursor = fde->fields;
size_t size;
fde->address = reader_->ReadEncodedPointer(cursor, fde->cie->pointer_encoding,
@@ -2852,10 +2852,10 @@
}
bool CallFrameInfo::Start() {
- const uint8_t *buffer_end = buffer_ + buffer_length_;
- const uint8_t *cursor;
+ const uint8_t* buffer_end = buffer_ + buffer_length_;
+ const uint8_t* cursor;
bool all_ok = true;
- const uint8_t *entry_end;
+ const uint8_t* entry_end;
bool ok;
// Traverse all the entries in buffer_, skipping CIEs and offering
@@ -2986,7 +2986,7 @@
return all_ok;
}
-const char *CallFrameInfo::KindName(EntryKind kind) {
+const char* CallFrameInfo::KindName(EntryKind kind) {
if (kind == CallFrameInfo::kUnknown)
return "entry";
else if (kind == CallFrameInfo::kCIE)
@@ -2999,7 +2999,7 @@
}
}
-bool CallFrameInfo::ReportIncomplete(Entry *entry) {
+bool CallFrameInfo::ReportIncomplete(Entry* entry) {
reporter_->Incomplete(entry->offset, entry->kind);
return false;
}
@@ -3058,7 +3058,7 @@
}
void CallFrameInfo::Reporter::UnrecognizedAugmentation(uint64_t offset,
- const string &aug) {
+ const string& aug) {
fprintf(stderr,
"%s: CFI frame description entry at offset 0x%" PRIx64 " in '%s':"
" CIE specifies unrecognized augmentation: '%s'\n",
diff --git a/src/common/dwarf/dwarf2reader.h b/src/common/dwarf/dwarf2reader.h
index e52f74c..83cd676 100644
--- a/src/common/dwarf/dwarf2reader.h
+++ b/src/common/dwarf/dwarf2reader.h
@@ -64,13 +64,13 @@
// This maps from a string naming a section to a pair containing a
// the data for the section, and the size of the section.
-typedef std::map<string, std::pair<const uint8_t *, uint64_t> > SectionMap;
+typedef std::map<string, std::pair<const uint8_t*, uint64_t> > SectionMap;
// Abstract away the difference between elf and mach-o section names.
// Elf-names use ".section_name, mach-o uses "__section_name". Pass "name" in
// the elf form, ".section_name".
const SectionMap::const_iterator GetSectionByName(const SectionMap&
- sections, const char *name);
+ sections, const char* name);
typedef std::list<std::pair<enum DwarfAttribute, enum DwarfForm> >
AttributeList;
@@ -88,7 +88,7 @@
uint8_t opcode_base;
// Use a pointer so that signalsafe_addr2line is able to use this structure
// without heap allocation problem.
- std::vector<unsigned char> *std_opcode_lengths;
+ std::vector<unsigned char>* std_opcode_lengths;
};
class LineInfo {
@@ -125,12 +125,12 @@
// lsm's old address < PC <= lsm's new address
static bool ProcessOneOpcode(ByteReader* reader,
LineInfoHandler* handler,
- const struct LineInfoHeader &header,
- const uint8_t *start,
+ const struct LineInfoHeader& header,
+ const uint8_t* start,
struct LineStateMachine* lsm,
size_t* len,
uintptr pc,
- bool *lsm_passes_pc);
+ bool* lsm_passes_pc);
private:
// Reads the DWARF2/3 header for this line info.
@@ -171,7 +171,7 @@
// buffer is the buffer for our line info, starting at exactly where
// the line info to read is. after_header is the place right after
// the end of the line information header.
- const uint8_t *buffer_;
+ const uint8_t* buffer_;
#ifndef NDEBUG
uint64_t buffer_length_;
#endif
@@ -182,7 +182,7 @@
const uint8_t* line_string_buffer_;
uint64_t line_string_buffer_length_;
- const uint8_t *after_header_;
+ const uint8_t* after_header_;
};
// This class is the main interface between the line info reader and
@@ -239,16 +239,16 @@
class RangeListReader {
public:
- RangeListReader(const uint8_t *buffer, uint64_t size, ByteReader *reader,
- RangeListHandler *handler);
+ RangeListReader(const uint8_t* buffer, uint64_t size, ByteReader* reader,
+ RangeListHandler* handler);
bool ReadRangeList(uint64_t offset);
private:
- const uint8_t *buffer_;
+ const uint8_t* buffer_;
uint64_t size_;
ByteReader* reader_;
- RangeListHandler *handler_;
+ RangeListHandler* handler_;
};
// This class is the main interface between the reader and the
@@ -322,7 +322,7 @@
virtual void ProcessAttributeBuffer(uint64_t offset,
enum DwarfAttribute attr,
enum DwarfForm form,
- const uint8_t *data,
+ const uint8_t* data,
uint64_t len) { }
// Called when we have an attribute with string data to give to our handler.
@@ -461,14 +461,14 @@
// Processes a single DIE for this compilation unit and return a new
// pointer just past the end of it
- const uint8_t *ProcessDIE(uint64_t dieoffset,
- const uint8_t *start,
+ const uint8_t* ProcessDIE(uint64_t dieoffset,
+ const uint8_t* start,
const Abbrev& abbrev);
// Processes a single attribute and return a new pointer just past the
// end of it
- const uint8_t *ProcessAttribute(uint64_t dieoffset,
- const uint8_t *start,
+ const uint8_t* ProcessAttribute(uint64_t dieoffset,
+ const uint8_t* start,
enum DwarfAttribute attr,
enum DwarfForm form);
@@ -564,11 +564,11 @@
// Skips the die with attributes specified in ABBREV starting at
// START, and return the new place to position the stream to.
- const uint8_t *SkipDIE(const uint8_t *start, const Abbrev& abbrev);
+ const uint8_t* SkipDIE(const uint8_t* start, const Abbrev& abbrev);
// Skips the attribute starting at START, with FORM, and return the
// new place to position the stream to.
- const uint8_t *SkipAttribute(const uint8_t *start, enum DwarfForm form);
+ const uint8_t* SkipAttribute(const uint8_t* start, enum DwarfForm form);
// Process the actual debug information in a split DWARF file.
void ProcessSplitDwarf();
@@ -587,9 +587,9 @@
// buffer is the buffer for our CU, starting at .debug_info + offset
// passed in from constructor.
// after_header points to right after the compilation unit header.
- const uint8_t *buffer_;
+ const uint8_t* buffer_;
uint64_t buffer_length_;
- const uint8_t *after_header_;
+ const uint8_t* after_header_;
// The associated ByteReader that handles endianness issues for us
ByteReader* reader_;
@@ -608,7 +608,7 @@
// String section buffer and length, if we have a string section.
// This is here to avoid doing a section lookup for strings in
// ProcessAttribute, which is in the hot path for DWARF2 reading.
- const uint8_t *string_buffer_;
+ const uint8_t* string_buffer_;
uint64_t string_buffer_length_;
// Similarly for .debug_line_string.
@@ -984,8 +984,8 @@
// The mechanics of C++ exception handling, personality routines,
// and language-specific data areas are described here, rather nicely:
// http://www.codesourcery.com/public/cxx-abi/abi-eh.html
- CallFrameInfo(const uint8_t *buffer, size_t buffer_length,
- ByteReader *reader, Handler *handler, Reporter *reporter,
+ CallFrameInfo(const uint8_t* buffer, size_t buffer_length,
+ ByteReader* reader, Handler* handler, Reporter* reporter,
bool eh_frame = false)
: buffer_(buffer), buffer_length_(buffer_length),
reader_(reader), handler_(handler), reporter_(reporter),
@@ -999,7 +999,7 @@
bool Start();
// Return the textual name of KIND. For error reporting.
- static const char *KindName(EntryKind kind);
+ static const char* KindName(EntryKind kind);
private:
@@ -1012,7 +1012,7 @@
size_t offset;
// The start of this entry in the buffer.
- const uint8_t *start;
+ const uint8_t* start;
// Which kind of entry this is.
//
@@ -1023,16 +1023,16 @@
// The end of this entry's common prologue (initial length and id), and
// the start of this entry's kind-specific fields.
- const uint8_t *fields;
+ const uint8_t* fields;
// The start of this entry's instructions.
- const uint8_t *instructions;
+ const uint8_t* instructions;
// The address past the entry's last byte in the buffer. (Note that
// since offset points to the entry's initial length field, and the
// length field is the number of bytes after that field, this is not
// simply buffer_ + offset + length.)
- const uint8_t *end;
+ const uint8_t* end;
// For both DWARF CFI and .eh_frame sections, this is the CIE id in a
// CIE, and the offset of the associated CIE in an FDE.
@@ -1040,7 +1040,7 @@
// The CIE that applies to this entry, if we've parsed it. If this is a
// CIE, then this field points to this structure.
- CIE *cie;
+ CIE* cie;
};
// A common information entry (CIE).
@@ -1114,14 +1114,14 @@
// true. On failure, report the problem, and return false. Even if we
// return false, set ENTRY->end to the first byte after the entry if we
// were able to figure that out, or NULL if we weren't.
- bool ReadEntryPrologue(const uint8_t *cursor, Entry *entry);
+ bool ReadEntryPrologue(const uint8_t* cursor, Entry* entry);
// Parse the fields of a CIE after the entry prologue, including any 'z'
// augmentation data. Assume that the 'Entry' fields of CIE are
// populated; use CIE->fields and CIE->end as the start and limit for
// parsing. On success, populate the rest of *CIE, and return true; on
// failure, report the problem and return false.
- bool ReadCIEFields(CIE *cie);
+ bool ReadCIEFields(CIE* cie);
// Parse the fields of an FDE after the entry prologue, including any 'z'
// augmentation data. Assume that the 'Entry' fields of *FDE are
@@ -1129,12 +1129,12 @@
// parsing. Assume that FDE->cie is fully initialized. On success,
// populate the rest of *FDE, and return true; on failure, report the
// problem and return false.
- bool ReadFDEFields(FDE *fde);
+ bool ReadFDEFields(FDE* fde);
// Report that ENTRY is incomplete, and return false. This is just a
// trivial wrapper for invoking reporter_->Incomplete; it provides a
// little brevity.
- bool ReportIncomplete(Entry *entry);
+ bool ReportIncomplete(Entry* entry);
// Return true if ENCODING has the DW_EH_PE_indirect bit set.
static bool IsIndirectEncoding(DwarfPointerEncoding encoding) {
@@ -1142,17 +1142,17 @@
}
// The contents of the DWARF .debug_info section we're parsing.
- const uint8_t *buffer_;
+ const uint8_t* buffer_;
size_t buffer_length_;
// For reading multi-byte values with the appropriate endianness.
- ByteReader *reader_;
+ ByteReader* reader_;
// The handler to which we should report the data we find.
- Handler *handler_;
+ Handler* handler_;
// For reporting problems in the info we're parsing.
- Reporter *reporter_;
+ Reporter* reporter_;
// True if we are processing .eh_frame-format data.
bool eh_frame_;
@@ -1185,7 +1185,7 @@
// process a given FDE, the parser reiterates the appropriate CIE's
// contents at the beginning of the FDE's rules.
virtual bool Entry(size_t offset, uint64_t address, uint64_t length,
- uint8_t version, const string &augmentation,
+ uint8_t version, const string& augmentation,
unsigned return_address) = 0;
// When the Entry function returns true, the parser calls these
@@ -1234,13 +1234,13 @@
// At ADDRESS, the DWARF expression EXPRESSION yields the address at
// which REG was saved.
virtual bool ExpressionRule(uint64_t address, int reg,
- const string &expression) = 0;
+ const string& expression) = 0;
// At ADDRESS, the DWARF expression EXPRESSION yields the caller's
// value for REG. (This rule doesn't provide an address at which the
// register's value is saved.)
virtual bool ValExpressionRule(uint64_t address, int reg,
- const string &expression) = 0;
+ const string& expression) = 0;
// Indicate that the rules for the address range reported by the
// last call to Entry are complete. End should return true if
@@ -1317,8 +1317,8 @@
// in a Mach-O section named __debug_frame. If we support
// Linux-style exception handling data, we could be reading an
// .eh_frame section.
- Reporter(const string &filename,
- const string §ion = ".debug_frame")
+ Reporter(const string& filename,
+ const string& section = ".debug_frame")
: filename_(filename), section_(section) { }
virtual ~Reporter() { }
@@ -1358,7 +1358,7 @@
// which we don't recognize. We cannot parse DWARF CFI if it uses
// augmentations we don't recognize.
virtual void UnrecognizedAugmentation(uint64_t offset,
- const string &augmentation);
+ const string& augmentation);
// The pointer encoding ENCODING, specified by the CIE at OFFSET, is not
// a valid encoding.
diff --git a/src/common/dwarf/dwarf2reader_cfi_unittest.cc b/src/common/dwarf/dwarf2reader_cfi_unittest.cc
index ebe612e..8e5d68b 100644
--- a/src/common/dwarf/dwarf2reader_cfi_unittest.cc
+++ b/src/common/dwarf/dwarf2reader_cfi_unittest.cc
@@ -87,7 +87,7 @@
#ifdef WRITE_ELF
void WriteELFFrameSection(const char *filename, const char *section_name,
- const CFISection §ion);
+ const CFISection& section);
#define PERHAPS_WRITE_DEBUG_FRAME_FILE(name, section) \
WriteELFFrameSection("cfitest-" name, ".debug_frame", section);
#define PERHAPS_WRITE_EH_FRAME_FILE(name, section) \
@@ -100,7 +100,7 @@
class MockCallFrameInfoHandler: public CallFrameInfo::Handler {
public:
MOCK_METHOD6(Entry, bool(size_t offset, uint64_t address, uint64_t length,
- uint8_t version, const string &augmentation,
+ uint8_t version, const string& augmentation,
unsigned return_address));
MOCK_METHOD2(UndefinedRule, bool(uint64_t address, int reg));
MOCK_METHOD2(SameValueRule, bool(uint64_t address, int reg));
@@ -110,9 +110,9 @@
long offset));
MOCK_METHOD3(RegisterRule, bool(uint64_t address, int reg, int base_register));
MOCK_METHOD3(ExpressionRule, bool(uint64_t address, int reg,
- const string &expression));
+ const string& expression));
MOCK_METHOD3(ValExpressionRule, bool(uint64_t address, int reg,
- const string &expression));
+ const string& expression));
MOCK_METHOD0(End, bool());
MOCK_METHOD2(PersonalityRoutine, bool(uint64_t address, bool indirect));
MOCK_METHOD2(LanguageSpecificDataArea, bool(uint64_t address, bool indirect));
@@ -129,7 +129,7 @@
MOCK_METHOD2(UnexpectedAddressSize, void(uint64_t, uint8_t));
MOCK_METHOD2(UnexpectedSegmentSize, void(uint64_t, uint8_t));
MOCK_METHOD2(UnrecognizedVersion, void(uint64_t, int version));
- MOCK_METHOD2(UnrecognizedAugmentation, void(uint64_t, const string &));
+ MOCK_METHOD2(UnrecognizedAugmentation, void(uint64_t, const string&));
MOCK_METHOD2(InvalidPointerEncoding, void(uint64_t, uint8_t));
MOCK_METHOD2(UnusablePointerEncoding, void(uint64_t, uint8_t));
MOCK_METHOD2(RestoreInCIE, void(uint64_t, uint64_t));
@@ -218,7 +218,7 @@
ByteReader byte_reader(ENDIANNESS_BIG);
byte_reader.SetAddressSize(8);
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size() - 2,
&byte_reader, &handler, &reporter);
EXPECT_FALSE(parser.Start());
@@ -244,7 +244,7 @@
ByteReader byte_reader(ENDIANNESS_LITTLE);
byte_reader.SetAddressSize(4);
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size() - 4,
&byte_reader, &handler, &reporter);
EXPECT_FALSE(parser.Start());
@@ -269,7 +269,7 @@
ByteReader byte_reader(ENDIANNESS_BIG);
byte_reader.SetAddressSize(8);
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size(),
&byte_reader, &handler, &reporter);
EXPECT_FALSE(parser.Start());
@@ -296,7 +296,7 @@
ByteReader byte_reader(ENDIANNESS_BIG);
byte_reader.SetAddressSize(8);
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size(),
&byte_reader, &handler, &reporter);
EXPECT_FALSE(parser.Start());
@@ -318,7 +318,7 @@
EXPECT_TRUE(section.GetContents(&contents));
ByteReader byte_reader(ENDIANNESS_LITTLE);
byte_reader.SetAddressSize(4);
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size(),
&byte_reader, &handler, &reporter);
EXPECT_TRUE(parser.Start());
@@ -349,7 +349,7 @@
EXPECT_TRUE(section.GetContents(&contents));
ByteReader byte_reader(ENDIANNESS_BIG);
byte_reader.SetAddressSize(4);
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size(),
&byte_reader, &handler, &reporter);
EXPECT_TRUE(parser.Start());
@@ -393,7 +393,7 @@
EXPECT_TRUE(section.GetContents(&contents));
ByteReader byte_reader(ENDIANNESS_BIG);
byte_reader.SetAddressSize(4);
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size(),
&byte_reader, &handler, &reporter);
EXPECT_TRUE(parser.Start());
@@ -443,7 +443,7 @@
EXPECT_TRUE(section.GetContents(&contents));
ByteReader byte_reader(ENDIANNESS_LITTLE);
byte_reader.SetAddressSize(8);
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size(),
&byte_reader, &handler, &reporter);
EXPECT_TRUE(parser.Start());
@@ -488,7 +488,7 @@
EXPECT_TRUE(section.GetContents(&contents));
ByteReader byte_reader(ENDIANNESS_BIG);
byte_reader.SetAddressSize(4);
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size(),
&byte_reader, &handler, &reporter);
EXPECT_FALSE(parser.Start());
@@ -533,7 +533,7 @@
EXPECT_TRUE(section.GetContents(&contents));
ByteReader byte_reader(ENDIANNESS_BIG);
byte_reader.SetAddressSize(4);
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size(),
&byte_reader, &handler, &reporter);
EXPECT_FALSE(parser.Start());
@@ -568,7 +568,7 @@
EXPECT_TRUE(section.GetContents(&contents));
ByteReader byte_reader(ENDIANNESS_BIG);
byte_reader.SetAddressSize(4);
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size(),
&byte_reader, &handler, &reporter);
EXPECT_TRUE(parser.Start());
@@ -603,7 +603,7 @@
EXPECT_TRUE(section.GetContents(&contents));
ByteReader byte_reader(ENDIANNESS_BIG);
byte_reader.SetAddressSize(4);
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size(),
&byte_reader, &handler, &reporter);
EXPECT_TRUE(parser.Start());
@@ -633,7 +633,7 @@
string contents;
EXPECT_TRUE(section.GetContents(&contents));
ByteReader byte_reader(ENDIANNESS_BIG);
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size(),
&byte_reader, &handler, &reporter);
EXPECT_TRUE(parser.Start());
@@ -663,7 +663,7 @@
string contents;
EXPECT_TRUE(section.GetContents(&contents));
ByteReader byte_reader(ENDIANNESS_BIG);
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size(),
&byte_reader, &handler, &reporter);
EXPECT_TRUE(parser.Start());
@@ -690,7 +690,7 @@
string contents;
EXPECT_TRUE(section.GetContents(&contents));
ByteReader byte_reader(ENDIANNESS_BIG);
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size(),
&byte_reader, &handler, &reporter);
EXPECT_FALSE(parser.Start());
@@ -715,7 +715,7 @@
string contents;
EXPECT_TRUE(section.GetContents(&contents));
ByteReader byte_reader(ENDIANNESS_BIG);
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size(),
&byte_reader, &handler, &reporter);
EXPECT_FALSE(parser.Start());
@@ -797,7 +797,7 @@
}
ByteReader byte_reader(endianness);
byte_reader.SetAddressSize(section->AddressSize());
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size(),
&byte_reader, &handler, &reporter);
if (succeeds)
@@ -2120,10 +2120,10 @@
ByteReader byte_reader(endianness);
byte_reader.SetAddressSize(section->AddressSize());
byte_reader.SetCFIDataBase(encoded_pointer_bases.cfi,
- reinterpret_cast<const uint8_t *>(contents.data()));
+ reinterpret_cast<const uint8_t*>(contents.data()));
byte_reader.SetTextBase(encoded_pointer_bases.text);
byte_reader.SetDataBase(encoded_pointer_bases.data);
- CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+ CallFrameInfo parser(reinterpret_cast<const uint8_t*>(contents.data()),
contents.size(),
&byte_reader, &handler, &reporter, true);
if (succeeds)
@@ -2468,7 +2468,7 @@
uint64_t entry_size;
};
-void AppendSectionHeader(CFISection *table, const ELFSectionHeader &header) {
+void AppendSectionHeader(CFISection* table, const ELFSectionHeader& header) {
(*table)
.D32(header.name) // name, index in string tbl
.D32(header.type) // type
@@ -2483,7 +2483,7 @@
}
void WriteELFFrameSection(const char *filename, const char *cfi_name,
- const CFISection &cfi) {
+ const CFISection& cfi) {
int elf_class = cfi.AddressSize() == 4 ? ELFCLASS32 : ELFCLASS64;
int elf_data = (cfi.endianness() == kBigEndian
? ELFDATA2MSB : ELFDATA2LSB);
diff --git a/src/common/dwarf/dwarf2reader_die_unittest.cc b/src/common/dwarf/dwarf2reader_die_unittest.cc
index ab9f7cb..8781932 100644
--- a/src/common/dwarf/dwarf2reader_die_unittest.cc
+++ b/src/common/dwarf/dwarf2reader_die_unittest.cc
@@ -93,7 +93,7 @@
MOCK_METHOD5(ProcessAttributeBuffer, void(uint64_t offset,
enum DwarfAttribute attr,
enum DwarfForm form,
- const uint8_t *data,
+ const uint8_t* data,
uint64_t len));
MOCK_METHOD4(ProcessAttributeString, void(uint64_t offset,
enum DwarfAttribute attr,
@@ -128,17 +128,17 @@
// to |info|, and whose .debug_abbrev section refers to |abbrevs|. This
// function returns a reference to the same SectionMap each time; new
// calls wipe out maps established by earlier calls.
- const SectionMap &MakeSectionMap() {
+ const SectionMap& MakeSectionMap() {
// Copy the sections' contents into strings that will live as long as
// the map itself.
assert(info.GetContents(&info_contents));
assert(abbrevs.GetContents(&abbrevs_contents));
section_map.clear();
section_map[".debug_info"].first
- = reinterpret_cast<const uint8_t *>(info_contents.data());
+ = reinterpret_cast<const uint8_t*>(info_contents.data());
section_map[".debug_info"].second = info_contents.size();
section_map[".debug_abbrev"].first
- = reinterpret_cast<const uint8_t *>(abbrevs_contents.data());
+ = reinterpret_cast<const uint8_t*>(abbrevs_contents.data());
section_map[".debug_abbrev"].second = abbrevs_contents.size();
return section_map;
}
@@ -240,7 +240,7 @@
// childless DIE of the given tag, with one attribute of the given name
// and form. The 'info' fixture member is left just after the abbrev
// code, waiting for the attribute value to be appended.
- void StartSingleAttributeDIE(const DwarfHeaderParams ¶ms,
+ void StartSingleAttributeDIE(const DwarfHeaderParams& params,
DwarfTag tag, DwarfAttribute name,
DwarfForm form) {
// Create the abbreviation table.
@@ -260,7 +260,7 @@
// Set up handler to expect a compilation unit matching |params|,
// containing one childless DIE of the given tag, in the sequence s. Stop
// just before the expectations.
- void ExpectBeginCompilationUnit(const DwarfHeaderParams ¶ms,
+ void ExpectBeginCompilationUnit(const DwarfHeaderParams& params,
DwarfTag tag, uint64_t offset=0) {
EXPECT_CALL(handler,
StartCompilationUnit(offset, params.address_size,
@@ -279,7 +279,7 @@
.WillOnce(Return());
}
- void ParseCompilationUnit(const DwarfHeaderParams ¶ms,
+ void ParseCompilationUnit(const DwarfHeaderParams& params,
uint64_t offset=0) {
ByteReader byte_reader(params.endianness == kLittleEndian ?
ENDIANNESS_LITTLE : ENDIANNESS_BIG);
diff --git a/src/common/dwarf/dwarf2reader_test_common.h b/src/common/dwarf/dwarf2reader_test_common.h
index c81d54a..1934094 100644
--- a/src/common/dwarf/dwarf2reader_test_common.h
+++ b/src/common/dwarf/dwarf2reader_test_common.h
@@ -70,7 +70,7 @@
// Append a DWARF compilation unit header to the section, with the given
// DWARF version, abbrev table offset, and address size.
- TestCompilationUnit &Header(int version, const Label &abbrev_offset,
+ TestCompilationUnit& Header(int version, const Label& abbrev_offset,
size_t address_size) {
if (format_size_ == 4) {
D32(length_);
@@ -92,7 +92,7 @@
}
// Mark the end of this header's DIEs.
- TestCompilationUnit &Finish() {
+ TestCompilationUnit& Finish() {
length_ = Size() - post_length_offset_;
return *this;
}
@@ -122,7 +122,7 @@
// Start a new abbreviation table entry for abbreviation code |code|,
// encoding a DIE whose tag is |tag|, and which has children if and only
// if |has_children| is true.
- TestAbbrevTable &Abbrev(int code, DwarfTag tag, DwarfHasChild has_children) {
+ TestAbbrevTable& Abbrev(int code, DwarfTag tag, DwarfHasChild has_children) {
assert(code != 0);
ULEB128(code);
ULEB128(static_cast<unsigned>(tag));
@@ -132,21 +132,21 @@
// Add an attribute to the current abbreviation code whose name is |name|
// and whose form is |form|.
- TestAbbrevTable &Attribute(DwarfAttribute name, DwarfForm form) {
+ TestAbbrevTable& Attribute(DwarfAttribute name, DwarfForm form) {
ULEB128(static_cast<unsigned>(name));
ULEB128(static_cast<unsigned>(form));
return *this;
}
// Finish the current abbreviation code.
- TestAbbrevTable &EndAbbrev() {
+ TestAbbrevTable& EndAbbrev() {
ULEB128(0);
ULEB128(0);
return *this;
}
// Finish the current abbreviation table.
- TestAbbrevTable &EndTable() {
+ TestAbbrevTable& EndTable() {
ULEB128(0);
return *this;
}
diff --git a/src/common/dwarf/elf_reader.cc b/src/common/dwarf/elf_reader.cc
index 1b66521..bbfdba6 100644
--- a/src/common/dwarf/elf_reader.cc
+++ b/src/common/dwarf/elf_reader.cc
@@ -130,11 +130,11 @@
static const int kElfClass = ELFCLASS32;
// Given a symbol pointer, return the binding type (eg STB_WEAK).
- static char Bind(const Elf32_Sym *sym) {
+ static char Bind(const Elf32_Sym* sym) {
return ELF32_ST_BIND(sym->st_info);
}
// Given a symbol pointer, return the symbol type (eg STT_FUNC).
- static char Type(const Elf32_Sym *sym) {
+ static char Type(const Elf32_Sym* sym) {
return ELF32_ST_TYPE(sym->st_info);
}
@@ -158,10 +158,10 @@
// What should be in the EI_CLASS header.
static const int kElfClass = ELFCLASS64;
- static char Bind(const Elf64_Sym *sym) {
+ static char Bind(const Elf64_Sym* sym) {
return ELF64_ST_BIND(sym->st_info);
}
- static char Type(const Elf64_Sym *sym) {
+ static char Type(const Elf64_Sym* sym) {
return ELF64_ST_TYPE(sym->st_info);
}
static int r_sym(const Elf64_Xword r_info) {
@@ -182,8 +182,8 @@
template<class ElfArch>
class ElfSectionReader {
public:
- ElfSectionReader(const char *name, const string &path, int fd,
- const typename ElfArch::Shdr §ion_header)
+ ElfSectionReader(const char* name, const string& path, int fd,
+ const typename ElfArch::Shdr& section_header)
: contents_aligned_(NULL),
contents_(NULL),
header_(section_header) {
@@ -199,7 +199,7 @@
contents_aligned_ = mmap(NULL, size_aligned_, PROT_READ, MAP_SHARED,
fd, offset_aligned);
// Set where the offset really should begin.
- contents_ = reinterpret_cast<char *>(contents_aligned_) +
+ contents_ = reinterpret_cast<char*>(contents_aligned_) +
(header_.sh_offset - offset_aligned);
// Check for and handle any compressed contents.
@@ -217,24 +217,24 @@
}
// Return the section header for this section.
- typename ElfArch::Shdr const &header() const { return header_; }
+ typename ElfArch::Shdr const& header() const { return header_; }
// Return memory at the given offset within this section.
- const char *GetOffset(typename ElfArch::Word bytes) const {
+ const char* GetOffset(typename ElfArch::Word bytes) const {
return contents_ + bytes;
}
- const char *contents() const { return contents_; }
+ const char* contents() const { return contents_; }
size_t section_size() const { return section_size_; }
private:
// page-aligned file contents
- void *contents_aligned_;
+ void* contents_aligned_;
// contents as usable by the client. For non-compressed sections,
// pointer within contents_aligned_ to where the section data
// begins; for compressed sections, pointer to the decompressed
// data.
- char *contents_;
+ char* contents_;
// size of contents_aligned_
size_t size_aligned_;
// size of contents.
@@ -249,7 +249,7 @@
template<class ElfArch>
class SymbolIterator {
public:
- SymbolIterator(ElfReaderImpl<ElfArch> *reader,
+ SymbolIterator(ElfReaderImpl<ElfArch>* reader,
typename ElfArch::Word section_type)
: symbol_section_(reader->GetSectionByType(section_type)),
string_section_(NULL),
@@ -280,7 +280,7 @@
// Return a pointer to the current symbol.
// REQUIRES: !done()
- const typename ElfArch::Sym *GetSymbol() const {
+ const typename ElfArch::Sym* GetSymbol() const {
return reinterpret_cast<const typename ElfArch::Sym*>(
symbol_section_->GetOffset(symbol_within_section_ *
symbol_section_->header().sh_entsize));
@@ -288,7 +288,7 @@
// Return the name of the current symbol, NULL if it has none.
// REQUIRES: !done()
- const char *GetSymbolName() const {
+ const char* GetSymbolName() const {
int name_offset = GetSymbol()->st_name;
if (name_offset == 0)
return NULL;
@@ -300,8 +300,8 @@
}
private:
- const ElfSectionReader<ElfArch> *const symbol_section_;
- const ElfSectionReader<ElfArch> *string_section_;
+ const ElfSectionReader<ElfArch>* const symbol_section_;
+ const ElfSectionReader<ElfArch>* string_section_;
int num_symbols_in_section_;
int symbol_within_section_;
};
@@ -326,7 +326,7 @@
template<class ElfArch>
class ElfReaderImpl {
public:
- explicit ElfReaderImpl(const string &path, int fd)
+ explicit ElfReaderImpl(const string& path, int fd)
: path_(path),
fd_(fd),
section_headers_(NULL),
@@ -347,7 +347,7 @@
// "opd_section_" must always be checked for NULL before use.
opd_section_ = GetSectionInfoByName(".opd", &opd_info_);
for (unsigned int k = 0u; k < GetNumSections(); ++k) {
- const char *name = GetSectionName(section_headers_[k].sh_name);
+ const char* name = GetSectionName(section_headers_[k].sh_name);
if (strncmp(name, ".text", strlen(".text")) == 0) {
base_for_text_ =
section_headers_[k].sh_addr - section_headers_[k].sh_offset;
@@ -384,7 +384,7 @@
// to see if the ELF file appears to match the current
// architecture. If error is non-NULL, it will be set with a reason
// in case of failure.
- static bool IsArchElfFile(int fd, string *error) {
+ static bool IsArchElfFile(int fd, string* error) {
unsigned char header[EI_NIDENT];
if (pread(fd, header, sizeof(header), 0) != sizeof(header)) {
if (error != NULL) *error = "Could not read header";
@@ -415,7 +415,7 @@
}
// Return true if we can use this symbol in Address-to-Symbol map.
- bool CanUseSymbol(const char *name, const typename ElfArch::Sym *sym) {
+ bool CanUseSymbol(const char* name, const typename ElfArch::Sym* sym) {
// For now we only save FUNC and NOTYPE symbols. For now we just
// care about functions, but some functions written in assembler
// don't have a proper ELF type attached to them, so we store
@@ -444,7 +444,7 @@
// Iterate over the symbols in a section, either SHT_DYNSYM or
// SHT_SYMTAB. Add all symbols to the given SymbolMap.
/*
- void GetSymbolPositions(SymbolMap *symbols,
+ void GetSymbolPositions(SymbolMap* symbols,
typename ElfArch::Word section_type,
uint64_t mem_offset,
uint64_t file_offset) {
@@ -453,10 +453,10 @@
AddrToSymMap addr_to_sym_map;
for (SymbolIterator<ElfArch> it(this, section_type);
!it.done(); it.Next()) {
- const char *name = it.GetSymbolName();
+ const char* name = it.GetSymbolName();
if (name == NULL)
continue;
- const typename ElfArch::Sym *sym = it.GetSymbol();
+ const typename ElfArch::Sym* sym = it.GetSymbol();
if (CanUseSymbol(name, sym)) {
const int sec = sym->st_shndx;
@@ -519,9 +519,9 @@
if (addr_to_sym_map.empty()) {
return;
}
- const ElfSectionReader<ElfArch> *const symbol_section =
+ const ElfSectionReader<ElfArch>* const symbol_section =
this->GetSectionByType(section_type);
- const ElfSectionReader<ElfArch> *const string_section =
+ const ElfSectionReader<ElfArch>* const string_section =
this->GetSection(symbol_section->header().sh_link);
typename AddrToSymMap::iterator curr = addr_to_sym_map.begin();
@@ -532,8 +532,8 @@
for (; curr != addr_to_sym_map.end(); ++curr) {
const uint64_t prev_addr = prev->first;
const uint64_t curr_addr = curr->first;
- const typename ElfArch::Sym *const prev_sym = prev->second;
- const typename ElfArch::Sym *const curr_sym = curr->second;
+ const typename ElfArch::Sym* const prev_sym = prev->second;
+ const typename ElfArch::Sym* const curr_sym = curr->second;
if (prev_addr + prev_sym->st_size <= curr_addr ||
// The next condition is true if two symbols overlap like this:
//
@@ -552,7 +552,7 @@
// (e.g. 0619e071) will produce the current symbol,
// which is the desired outcome.
prev_addr + prev_sym->st_size < curr_addr + curr_sym->st_size) {
- const char *name = string_section->GetOffset(curr_sym->st_name);
+ const char* name = string_section->GetOffset(curr_sym->st_name);
symbols->AddSymbol(name, curr_addr, curr_sym->st_size);
prev = curr;
} else {
@@ -572,20 +572,20 @@
*/
void VisitSymbols(typename ElfArch::Word section_type,
- ElfReader::SymbolSink *sink) {
+ ElfReader::SymbolSink* sink) {
VisitSymbols(section_type, sink, -1, -1, false);
}
void VisitSymbols(typename ElfArch::Word section_type,
- ElfReader::SymbolSink *sink,
+ ElfReader::SymbolSink* sink,
int symbol_binding,
int symbol_type,
bool get_raw_symbol_values) {
for (SymbolIterator<ElfArch> it(this, section_type);
!it.done(); it.Next()) {
- const char *name = it.GetSymbolName();
+ const char* name = it.GetSymbolName();
if (!name) continue;
- const typename ElfArch::Sym *sym = it.GetSymbol();
+ const typename ElfArch::Sym* sym = it.GetSymbol();
if ((symbol_binding < 0 || ElfArch::Bind(sym) == symbol_binding) &&
(symbol_type < 0 || ElfArch::Type(sym) == symbol_type)) {
typename ElfArch::Sym symbol = *sym;
@@ -691,7 +691,7 @@
// Return an ElfSectionReader for the first section of the given
// type by iterating through all section headers. Returns NULL if
// the section type is not found.
- const ElfSectionReader<ElfArch> *GetSectionByType(
+ const ElfSectionReader<ElfArch>* GetSectionByType(
typename ElfArch::Word section_type) {
for (unsigned int k = 0u; k < GetNumSections(); ++k) {
if (section_headers_[k].sh_type == section_type) {
@@ -703,14 +703,14 @@
// Return the name of section "shndx". Returns NULL if the section
// is not found.
- const char *GetSectionNameByIndex(int shndx) {
+ const char* GetSectionNameByIndex(int shndx) {
return GetSectionName(section_headers_[shndx].sh_name);
}
// Return a pointer to section "shndx", and store the size in
// "size". Returns NULL if the section is not found.
- const char *GetSectionContentsByIndex(int shndx, size_t *size) {
- const ElfSectionReader<ElfArch> *section = GetSection(shndx);
+ const char* GetSectionContentsByIndex(int shndx, size_t* size) {
+ const ElfSectionReader<ElfArch>* section = GetSection(shndx);
if (section != NULL) {
*size = section->section_size();
return section->contents();
@@ -721,16 +721,16 @@
// Return a pointer to the first section of the given name by
// iterating through all section headers, and store the size in
// "size". Returns NULL if the section name is not found.
- const char *GetSectionContentsByName(const string §ion_name,
- size_t *size) {
+ const char* GetSectionContentsByName(const string& section_name,
+ size_t* size) {
for (unsigned int k = 0u; k < GetNumSections(); ++k) {
// When searching for sections in a .dwp file, the sections
// we're looking for will always be at the end of the section
// table, so reverse the direction of iteration.
int shndx = is_dwp_ ? GetNumSections() - k - 1 : k;
- const char *name = GetSectionName(section_headers_[shndx].sh_name);
+ const char* name = GetSectionName(section_headers_[shndx].sh_name);
if (name != NULL && ElfReader::SectionNamesMatch(section_name, name)) {
- const ElfSectionReader<ElfArch> *section = GetSection(shndx);
+ const ElfSectionReader<ElfArch>* section = GetSection(shndx);
if (section == NULL) {
return NULL;
} else {
@@ -744,16 +744,16 @@
// This is like GetSectionContentsByName() but it returns a lot of extra
// information about the section.
- const char *GetSectionInfoByName(const string §ion_name,
- ElfReader::SectionInfo *info) {
+ const char* GetSectionInfoByName(const string& section_name,
+ ElfReader::SectionInfo* info) {
for (unsigned int k = 0u; k < GetNumSections(); ++k) {
// When searching for sections in a .dwp file, the sections
// we're looking for will always be at the end of the section
// table, so reverse the direction of iteration.
int shndx = is_dwp_ ? GetNumSections() - k - 1 : k;
- const char *name = GetSectionName(section_headers_[shndx].sh_name);
+ const char* name = GetSectionName(section_headers_[shndx].sh_name);
if (name != NULL && ElfReader::SectionNamesMatch(section_name, name)) {
- const ElfSectionReader<ElfArch> *section = GetSection(shndx);
+ const ElfSectionReader<ElfArch>* section = GetSection(shndx);
if (section == NULL) {
return NULL;
} else {
@@ -797,7 +797,7 @@
// Debug sections are likely to be near the end, so reverse the
// direction of iteration.
for (int k = GetNumSections() - 1; k >= 0; --k) {
- const char *name = GetSectionName(section_headers_[k].sh_name);
+ const char* name = GetSectionName(section_headers_[k].sh_name);
if (strncmp(name, ".debug", strlen(".debug")) == 0) return true;
if (strncmp(name, ".zdebug", strlen(".zdebug")) == 0) return true;
}
@@ -816,7 +816,7 @@
}
private:
- typedef vector<pair<uint64_t, const typename ElfArch::Sym *> > AddrToSymMap;
+ typedef vector<pair<uint64_t, const typename ElfArch::Sym*> > AddrToSymMap;
static bool AddrToSymSorter(const typename AddrToSymMap::value_type& lhs,
const typename AddrToSymMap::value_type& rhs) {
@@ -854,8 +854,8 @@
// Given an offset into the section header string table, return the
// section name.
- const char *GetSectionName(typename ElfArch::Word sh_name) {
- const ElfSectionReader<ElfArch> *shstrtab =
+ const char* GetSectionName(typename ElfArch::Word sh_name) {
+ const ElfSectionReader<ElfArch>* shstrtab =
GetSection(GetStringTableIndex());
if (shstrtab != NULL) {
return shstrtab->GetOffset(sh_name);
@@ -865,15 +865,15 @@
// Return an ElfSectionReader for the given section. The reader will
// be freed when this object is destroyed.
- const ElfSectionReader<ElfArch> *GetSection(int num) {
- const char *name;
+ const ElfSectionReader<ElfArch>* GetSection(int num) {
+ const char* name;
// Hard-coding the name for the section-name string table prevents
// infinite recursion.
if (num == GetStringTableIndex())
name = ".shstrtab";
else
name = GetSectionNameByIndex(num);
- ElfSectionReader<ElfArch> *& reader = sections_[num];
+ ElfSectionReader<ElfArch>*& reader = sections_[num];
if (reader == NULL)
reader = new ElfSectionReader<ElfArch>(name, path_, fd_,
section_headers_[num]);
@@ -883,7 +883,7 @@
// Parse out the overall header information from the file and assert
// that it looks sane. This contains information like the magic
// number and target architecture.
- bool ParseHeaders(int fd, const string &path) {
+ bool ParseHeaders(int fd, const string& path) {
// Read in the global ELF header.
if (pread(fd, &header_, sizeof(header_), 0) != sizeof(header_)) {
return false;
@@ -985,11 +985,11 @@
// Array of GetNumSections() section headers, allocated when we read
// in the global header.
- typename ElfArch::Shdr *section_headers_;
+ typename ElfArch::Shdr* section_headers_;
// Array of GetNumProgramHeaders() program headers, allocated when we read
// in the global header.
- typename ElfArch::Phdr *program_headers_;
+ typename ElfArch::Phdr* program_headers_;
// An array of pointers to ElfSectionReaders. Sections are
// mmaped as they're needed and not released until this object is
@@ -1000,7 +1000,7 @@
// values for funtion symbols values. Function descriptors are kept in the
// .opd section and are dereferenced to find the function address.
ElfReader::SectionInfo opd_info_;
- const char *opd_section_; // Must be checked for NULL before use.
+ const char* opd_section_; // Must be checked for NULL before use.
int64_t base_for_text_;
// Read PLT-related sections for the current architecture.
@@ -1026,7 +1026,7 @@
bool is_dwp_;
};
-ElfReader::ElfReader(const string &path)
+ElfReader::ElfReader(const string& path)
: path_(path), fd_(-1), impl32_(NULL), impl64_(NULL) {
// linux 2.6.XX kernel can show deleted files like this:
// /var/run/nscd/dbYLJYaE (deleted)
@@ -1063,7 +1063,7 @@
#endif
template <typename ElfArch>
-static bool IsElfFile(const int fd, const string &path) {
+static bool IsElfFile(const int fd, const string& path) {
if (fd < 0)
return false;
if (!ElfReaderImpl<ElfArch>::IsArchElfFile(fd, NULL)) {
@@ -1086,7 +1086,7 @@
}
/*
-void ElfReader::AddSymbols(SymbolMap *symbols,
+void ElfReader::AddSymbols(SymbolMap* symbols,
uint64_t mem_offset, uint64_t file_offset,
uint64_t length) {
if (fd_ < 0)
@@ -1109,17 +1109,17 @@
}
*/
-void ElfReader::VisitSymbols(ElfReader::SymbolSink *sink) {
+void ElfReader::VisitSymbols(ElfReader::SymbolSink* sink) {
VisitSymbols(sink, -1, -1);
}
-void ElfReader::VisitSymbols(ElfReader::SymbolSink *sink,
+void ElfReader::VisitSymbols(ElfReader::SymbolSink* sink,
int symbol_binding,
int symbol_type) {
VisitSymbols(sink, symbol_binding, symbol_type, false);
}
-void ElfReader::VisitSymbols(ElfReader::SymbolSink *sink,
+void ElfReader::VisitSymbols(ElfReader::SymbolSink* sink,
int symbol_binding,
int symbol_type,
bool get_raw_symbol_values) {
@@ -1148,7 +1148,7 @@
}
}
-const char *ElfReader::GetSectionName(int shndx) {
+const char* ElfReader::GetSectionName(int shndx) {
if (shndx < 0 || static_cast<unsigned int>(shndx) >= GetNumSections()) return NULL;
if (IsElf32File()) {
return GetImpl32()->GetSectionNameByIndex(shndx);
@@ -1169,7 +1169,7 @@
}
}
-const char *ElfReader::GetSectionByIndex(int shndx, size_t *size) {
+const char* ElfReader::GetSectionByIndex(int shndx, size_t* size) {
if (IsElf32File()) {
return GetImpl32()->GetSectionContentsByIndex(shndx, size);
} else if (IsElf64File()) {
@@ -1179,8 +1179,8 @@
}
}
-const char *ElfReader::GetSectionByName(const string §ion_name,
- size_t *size) {
+const char* ElfReader::GetSectionByName(const string& section_name,
+ size_t* size) {
if (IsElf32File()) {
return GetImpl32()->GetSectionContentsByName(section_name, size);
} else if (IsElf64File()) {
@@ -1190,8 +1190,8 @@
}
}
-const char *ElfReader::GetSectionInfoByName(const string §ion_name,
- SectionInfo *info) {
+const char* ElfReader::GetSectionInfoByName(const string& section_name,
+ SectionInfo* info) {
if (IsElf32File()) {
return GetImpl32()->GetSectionInfoByName(section_name, info);
} else if (IsElf64File()) {
@@ -1201,7 +1201,7 @@
}
}
-bool ElfReader::SectionNamesMatch(const string &name, const string &sh_name) {
+bool ElfReader::SectionNamesMatch(const string& name, const string& sh_name) {
if ((name.find(".debug_", 0) == 0) && (sh_name.find(".zdebug_", 0) == 0)) {
const string name_suffix(name, strlen(".debug_"));
const string sh_name_suffix(sh_name, strlen(".zdebug_"));
@@ -1220,14 +1220,14 @@
}
}
-ElfReaderImpl<Elf32> *ElfReader::GetImpl32() {
+ElfReaderImpl<Elf32>* ElfReader::GetImpl32() {
if (impl32_ == NULL) {
impl32_ = new ElfReaderImpl<Elf32>(path_, fd_);
}
return impl32_;
}
-ElfReaderImpl<Elf64> *ElfReader::GetImpl64() {
+ElfReaderImpl<Elf64>* ElfReader::GetImpl64() {
if (impl64_ == NULL) {
impl64_ = new ElfReaderImpl<Elf64>(path_, fd_);
}
@@ -1238,7 +1238,7 @@
// debug info (debug_only=true) or symbol table (debug_only=false).
// Otherwise, return false.
template <typename ElfArch>
-static bool IsNonStrippedELFBinaryImpl(const string &path, const int fd,
+static bool IsNonStrippedELFBinaryImpl(const string& path, const int fd,
bool debug_only) {
if (!ElfReaderImpl<ElfArch>::IsArchElfFile(fd, NULL)) return false;
ElfReaderImpl<ElfArch> elf_reader(path, fd);
@@ -1248,7 +1248,7 @@
}
// Helper for the IsNon[Debug]StrippedELFBinary functions.
-static bool IsNonStrippedELFBinaryHelper(const string &path,
+static bool IsNonStrippedELFBinaryHelper(const string& path,
bool debug_only) {
const int fd = open(path.c_str(), O_RDONLY);
if (fd == -1) {
@@ -1264,11 +1264,11 @@
return false;
}
-bool ElfReader::IsNonStrippedELFBinary(const string &path) {
+bool ElfReader::IsNonStrippedELFBinary(const string& path) {
return IsNonStrippedELFBinaryHelper(path, false);
}
-bool ElfReader::IsNonDebugStrippedELFBinary(const string &path) {
+bool ElfReader::IsNonDebugStrippedELFBinary(const string& path) {
return IsNonStrippedELFBinaryHelper(path, true);
}
} // namespace dwarf2reader
diff --git a/src/common/dwarf/elf_reader.h b/src/common/dwarf/elf_reader.h
index 8eaa5aa..0aa9228 100644
--- a/src/common/dwarf/elf_reader.h
+++ b/src/common/dwarf/elf_reader.h
@@ -34,7 +34,7 @@
class ElfReader {
public:
- explicit ElfReader(const string &path);
+ explicit ElfReader(const string& path);
~ElfReader();
// Parse the ELF prologue of this file and return whether it was
@@ -62,29 +62,29 @@
// mem_offset - position at which the segment is mapped into memory
// file_offset - offset in the file where the mapping begins
// length - length of the mapped segment
- void AddSymbols(SymbolMap *symbols,
+ void AddSymbols(SymbolMap* symbols,
uint64_t mem_offset, uint64_t file_offset,
uint64_t length);
class SymbolSink {
public:
virtual ~SymbolSink() {}
- virtual void AddSymbol(const char *name, uint64_t address,
+ virtual void AddSymbol(const char* name, uint64_t address,
uint64_t size) = 0;
};
// Like AddSymbols above, but with no address correction.
// Processes any SHT_SYMTAB section, followed by any SHT_DYNSYM section.
- void VisitSymbols(SymbolSink *sink);
+ void VisitSymbols(SymbolSink* sink);
// Like VisitSymbols above, but for a specific symbol binding/type.
// A negative value for the binding and type parameters means any
// binding or type.
- void VisitSymbols(SymbolSink *sink, int symbol_binding, int symbol_type);
+ void VisitSymbols(SymbolSink* sink, int symbol_binding, int symbol_type);
// Like VisitSymbols above but can optionally export raw symbol values instead
// of adjusted ones.
- void VisitSymbols(SymbolSink *sink, int symbol_binding, int symbol_type,
+ void VisitSymbols(SymbolSink* sink, int symbol_binding, int symbol_type,
bool get_raw_symbol_values);
// p_vaddr of the first PT_LOAD segment (if any), or 0 if no PT_LOAD
@@ -95,7 +95,7 @@
// Return the name of section "shndx". Returns NULL if the section
// is not found.
- const char *GetSectionName(int shndx);
+ const char* GetSectionName(int shndx);
// Return the number of sections in the given ELF file.
uint64_t GetNumSections();
@@ -104,14 +104,14 @@
// the pointer to the section and store the size in "size".
// On error, return NULL. The returned section data is only valid
// until the ElfReader gets destroyed.
- const char *GetSectionByIndex(int shndx, size_t *size);
+ const char* GetSectionByIndex(int shndx, size_t* size);
// Get section with "section_name" (ex. ".text", ".symtab") in the
// given ELF file. On success, return the pointer to the section
// and store the size in "size". On error, return NULL. The
// returned section data is only valid until the ElfReader gets
// destroyed.
- const char *GetSectionByName(const string §ion_name, size_t *size);
+ const char* GetSectionByName(const string& section_name, size_t* size);
// This is like GetSectionByName() but it returns a lot of extra information
// about the section. The SectionInfo structure is almost identical to
@@ -129,37 +129,37 @@
uint64_t addralign; // Section alignment.
uint64_t entsize; // Entry size if section holds a table.
};
- const char *GetSectionInfoByName(const string §ion_name,
- SectionInfo *info);
+ const char* GetSectionInfoByName(const string& section_name,
+ SectionInfo* info);
// Check if "path" is an ELF binary that has not been stripped of symbol
// tables. This function supports both 32-bit and 64-bit ELF binaries.
- static bool IsNonStrippedELFBinary(const string &path);
+ static bool IsNonStrippedELFBinary(const string& path);
// Check if "path" is an ELF binary that has not been stripped of debug
// info. Unlike IsNonStrippedELFBinary, this function will return
// false for binaries passed through "strip -S".
- static bool IsNonDebugStrippedELFBinary(const string &path);
+ static bool IsNonDebugStrippedELFBinary(const string& path);
// Match a requested section name with the section name as it
// appears in the elf-file, adjusting for compressed debug section
// names. For example, returns true if name == ".debug_abbrev" and
// sh_name == ".zdebug_abbrev"
- static bool SectionNamesMatch(const string &name, const string &sh_name);
+ static bool SectionNamesMatch(const string& name, const string& sh_name);
private:
// Lazily initialize impl32_ and return it.
- ElfReaderImpl<Elf32> *GetImpl32();
+ ElfReaderImpl<Elf32>* GetImpl32();
// Ditto for impl64_.
- ElfReaderImpl<Elf64> *GetImpl64();
+ ElfReaderImpl<Elf64>* GetImpl64();
// Path of the file we're reading.
const string path_;
// Read-only file descriptor for the file. May be -1 if there was an
// error during open.
int fd_;
- ElfReaderImpl<Elf32> *impl32_;
- ElfReaderImpl<Elf64> *impl64_;
+ ElfReaderImpl<Elf32>* impl32_;
+ ElfReaderImpl<Elf64>* impl64_;
};
} // namespace dwarf2reader
diff --git a/src/common/dwarf/functioninfo.cc b/src/common/dwarf/functioninfo.cc
index 28c4f93..6b9a92a 100644
--- a/src/common/dwarf/functioninfo.cc
+++ b/src/common/dwarf/functioninfo.cc
@@ -144,7 +144,7 @@
void CUFunctionInfoHandler::ProcessAttributeString(uint64_t offset,
enum DwarfAttribute attr,
enum DwarfForm form,
- const string &data) {
+ const string& data) {
if (current_function_info_) {
if (attr == DW_AT_name)
current_function_info_->name = data;
diff --git a/src/common/dwarf_cfi_to_module.cc b/src/common/dwarf_cfi_to_module.cc
index 3dd85ed..eb19c13 100644
--- a/src/common/dwarf_cfi_to_module.cc
+++ b/src/common/dwarf_cfi_to_module.cc
@@ -143,7 +143,7 @@
}
bool DwarfCFIToModule::Entry(size_t offset, uint64_t address, uint64_t length,
- uint8_t version, const string &augmentation,
+ uint8_t version, const string& augmentation,
unsigned return_address) {
assert(!entry_);
@@ -190,7 +190,7 @@
}
void DwarfCFIToModule::Record(Module::Address address, int reg,
- const string &rule) {
+ const string& rule) {
assert(entry_);
// Place the name in our global set of strings, and then use the string
@@ -247,14 +247,14 @@
}
bool DwarfCFIToModule::ExpressionRule(uint64_t address, int reg,
- const string &expression) {
+ const string& expression) {
reporter_->ExpressionsNotSupported(entry_offset_, RegisterName(reg));
// Treat this as a non-fatal error.
return true;
}
bool DwarfCFIToModule::ValExpressionRule(uint64_t address, int reg,
- const string &expression) {
+ const string& expression) {
reporter_->ExpressionsNotSupported(entry_offset_, RegisterName(reg));
// Treat this as a non-fatal error.
return true;
@@ -274,7 +274,7 @@
}
void DwarfCFIToModule::Reporter::UndefinedNotSupported(size_t offset,
- const string ®) {
+ const string& reg) {
fprintf(stderr, "%s, section '%s': "
"the call frame entry at offset 0x%zx sets the rule for "
"register '%s' to 'undefined', but the Breakpad symbol file format"
@@ -283,7 +283,7 @@
}
void DwarfCFIToModule::Reporter::ExpressionsNotSupported(size_t offset,
- const string ®) {
+ const string& reg) {
fprintf(stderr, "%s, section '%s': "
"the call frame entry at offset 0x%zx uses a DWARF expression to"
" describe how to recover register '%s', "
diff --git a/src/common/dwarf_cfi_to_module.h b/src/common/dwarf_cfi_to_module.h
index 4d2db7e..35bdb5f 100644
--- a/src/common/dwarf_cfi_to_module.h
+++ b/src/common/dwarf_cfi_to_module.h
@@ -71,7 +71,7 @@
// stream. FILE is the name of the file we're processing, and
// SECTION is the name of the section within that file that we're
// looking at (.debug_frame, .eh_frame, etc.).
- Reporter(const string &file, const string §ion)
+ Reporter(const string& file, const string& section)
: file_(file), section_(section) { }
virtual ~Reporter() { }
@@ -83,13 +83,13 @@
// The DWARF CFI entry at OFFSET says that REG is undefined, but the
// Breakpad symbol file format cannot express this.
- virtual void UndefinedNotSupported(size_t offset, const string ®);
+ virtual void UndefinedNotSupported(size_t offset, const string& reg);
// The DWARF CFI entry at OFFSET says that REG uses a DWARF
// expression to find its value, but DwarfCFIToModule is not
// capable of translating DWARF expressions to Breakpad postfix
// expressions.
- virtual void ExpressionsNotSupported(size_t offset, const string ®);
+ virtual void ExpressionsNotSupported(size_t offset, const string& reg);
protected:
string file_, section_;
@@ -118,7 +118,7 @@
private:
// Given STRINGS, an array of C strings with SIZE elements, return an
// equivalent vector<string>.
- static vector<string> MakeVector(const char * const *strings, size_t size);
+ static vector<string> MakeVector(const char* const* strings, size_t size);
};
// Create a handler for the dwarf2reader::CallFrameInfo parser that
@@ -130,15 +130,15 @@
//
// Use REPORTER for reporting problems encountered in the conversion
// process.
- DwarfCFIToModule(Module *module, const vector<string> ®ister_names,
- Reporter *reporter)
+ DwarfCFIToModule(Module* module, const vector<string>& register_names,
+ Reporter* reporter)
: module_(module), register_names_(register_names), reporter_(reporter),
entry_(NULL), return_address_(-1), cfa_name_(".cfa"), ra_name_(".ra") {
}
virtual ~DwarfCFIToModule() { delete entry_; }
virtual bool Entry(size_t offset, uint64_t address, uint64_t length,
- uint8_t version, const string &augmentation,
+ uint8_t version, const string& augmentation,
unsigned return_address);
virtual bool UndefinedRule(uint64_t address, int reg);
virtual bool SameValueRule(uint64_t address, int reg);
@@ -148,9 +148,9 @@
int base_register, long offset);
virtual bool RegisterRule(uint64_t address, int reg, int base_register);
virtual bool ExpressionRule(uint64_t address, int reg,
- const string &expression);
+ const string& expression);
virtual bool ValExpressionRule(uint64_t address, int reg,
- const string &expression);
+ const string& expression);
virtual bool End();
private:
@@ -158,19 +158,19 @@
string RegisterName(int i);
// Record RULE for register REG at ADDRESS.
- void Record(Module::Address address, int reg, const string &rule);
+ void Record(Module::Address address, int reg, const string& rule);
// The module to which we should add entries.
- Module *module_;
+ Module* module_;
// Map from register numbers to register names.
- const vector<string> ®ister_names_;
+ const vector<string>& register_names_;
// The reporter to use to report problems.
- Reporter *reporter_;
+ Reporter* reporter_;
// The current entry we're constructing.
- Module::StackFrameEntry *entry_;
+ Module::StackFrameEntry* entry_;
// The section offset of the current frame description entry, for
// use in error messages.
diff --git a/src/common/dwarf_cfi_to_module_unittest.cc b/src/common/dwarf_cfi_to_module_unittest.cc
index 60a9a3e..58c3cca 100644
--- a/src/common/dwarf_cfi_to_module_unittest.cc
+++ b/src/common/dwarf_cfi_to_module_unittest.cc
@@ -47,11 +47,11 @@
using testing::_;
struct MockCFIReporter: public DwarfCFIToModule::Reporter {
- MockCFIReporter(const string &file, const string §ion)
+ MockCFIReporter(const string& file, const string& section)
: Reporter(file, section) { }
MOCK_METHOD2(UnnamedRegister, void(size_t offset, int reg));
- MOCK_METHOD2(UndefinedNotSupported, void(size_t offset, const string ®));
- MOCK_METHOD2(ExpressionsNotSupported, void(size_t offset, const string ®));
+ MOCK_METHOD2(UndefinedNotSupported, void(size_t offset, const string& reg));
+ MOCK_METHOD2(ExpressionsNotSupported, void(size_t offset, const string& reg));
};
struct DwarfCFIToModuleFixture {
@@ -80,7 +80,7 @@
vector<string> register_names;
MockCFIReporter reporter;
DwarfCFIToModule handler;
- vector<Module::StackFrameEntry *> entries;
+ vector<Module::StackFrameEntry*> entries;
};
class Entry: public DwarfCFIToModuleFixture, public Test { };
diff --git a/src/common/dwarf_cu_to_module.cc b/src/common/dwarf_cu_to_module.cc
index ec2badc..3a52085 100644
--- a/src/common/dwarf_cu_to_module.cc
+++ b/src/common/dwarf_cu_to_module.cc
@@ -128,8 +128,8 @@
AbstractOriginByOffset origins;
};
-DwarfCUToModule::FileContext::FileContext(const string &filename,
- Module *module,
+DwarfCUToModule::FileContext::FileContext(const string& filename,
+ Module* module,
bool handle_inter_cu_refs)
: filename_(filename),
module_(module),
@@ -141,7 +141,7 @@
}
void DwarfCUToModule::FileContext::AddSectionToSectionMap(
- const string& name, const uint8_t *contents, uint64_t length) {
+ const string& name, const uint8_t* contents, uint64_t length) {
section_map_[name] = std::make_pair(contents, length);
}
@@ -170,8 +170,8 @@
// parsing. This is for data shared across the CU's entire DIE tree,
// and parameters from the code invoking the CU parser.
struct DwarfCUToModule::CUContext {
- CUContext(FileContext *file_context_arg, WarningReporter *reporter_arg,
- RangesHandler *ranges_handler_arg)
+ CUContext(FileContext* file_context_arg, WarningReporter* reporter_arg,
+ RangesHandler* ranges_handler_arg)
: file_context(file_context_arg),
reporter(reporter_arg),
ranges_handler(ranges_handler_arg),
@@ -181,23 +181,23 @@
ranges(0) {}
~CUContext() {
- for (vector<Module::Function *>::iterator it = functions.begin();
+ for (vector<Module::Function*>::iterator it = functions.begin();
it != functions.end(); ++it) {
delete *it;
}
};
// The DWARF-bearing file into which this CU was incorporated.
- FileContext *file_context;
+ FileContext* file_context;
// For printing error messages.
- WarningReporter *reporter;
+ WarningReporter* reporter;
// For reading ranges from the .debug_ranges section
- RangesHandler *ranges_handler;
+ RangesHandler* ranges_handler;
// The source language of this compilation unit.
- const Language *language;
+ const Language* language;
// Addresses covered by this CU. If high_pc_ is non-zero then the CU covers
// low_pc to high_pc, otherwise ranges is non-zero and low_pc represents
@@ -211,11 +211,11 @@
// assign them lines and add them to file_context->module.
//
// Destroying this destroys all the functions this vector points to.
- vector<Module::Function *> functions;
+ vector<Module::Function*> functions;
// Keep a list of forward references from DW_AT_abstract_origin and
// DW_AT_specification attributes so names can be fixed up.
- std::map<uint64_t, Module::Function *> forward_ref_die_to_func;
+ std::map<uint64_t, Module::Function*> forward_ref_die_to_func;
};
// Information about the context of a particular DIE. This is for
@@ -241,7 +241,7 @@
// Create a handler for the DIE at OFFSET whose compilation unit is
// described by CU_CONTEXT, and whose immediate context is described
// by PARENT_CONTEXT.
- GenericDIEHandler(CUContext *cu_context, DIEContext *parent_context,
+ GenericDIEHandler(CUContext* cu_context, DIEContext* parent_context,
uint64_t offset)
: cu_context_(cu_context),
parent_context_(parent_context),
@@ -266,7 +266,7 @@
// handle DW_AT_specification, or simply not override it.
void ProcessAttributeString(enum DwarfAttribute attr,
enum DwarfForm form,
- const string &data);
+ const string& data);
protected:
// Compute and return the fully-qualified name of the DIE. If this
@@ -279,8 +279,8 @@
// have been seen.
string ComputeQualifiedName();
- CUContext *cu_context_;
- DIEContext *parent_context_;
+ CUContext* cu_context_;
+ DIEContext* parent_context_;
uint64_t offset_;
// Place the name in the global set of strings. Even though this looks
@@ -289,7 +289,7 @@
// share copies of strings whenever possible.
// FIXME: Should this return something like a string_ref to avoid the
// assumption about how strings are implemented?
- string AddStringToPool(const string &str);
+ string AddStringToPool(const string& str);
// If this DIE has a DW_AT_declaration attribute, this is its value.
// It is false on DIEs with no DW_AT_declaration attribute.
@@ -298,7 +298,7 @@
// If this DIE has a DW_AT_specification attribute, this is the
// Specification structure for the DIE the attribute refers to.
// Otherwise, this is NULL.
- Specification *specification_;
+ Specification* specification_;
// If this DIE has a DW_AT_specification or DW_AT_abstract_origin and it is a
// forward reference, no Specification will be available. Track the reference
@@ -335,7 +335,7 @@
uint64_t data) {
switch (attr) {
case dwarf2reader::DW_AT_specification: {
- FileContext *file_context = cu_context_->file_context;
+ FileContext* file_context = cu_context_->file_context;
if (file_context->IsUnhandledInterCUReference(
data, cu_context_->reporter->cu_offset())) {
cu_context_->reporter->UnhandledInterCUReference(offset_, data);
@@ -346,7 +346,7 @@
// here, but it's better to leave the real work to our
// EndAttribute member function, at which point we know we have
// seen all the DIE's attributes.
- SpecificationByOffset *specifications =
+ SpecificationByOffset* specifications =
&file_context->file_private_->specifications;
SpecificationByOffset::iterator spec = specifications->find(data);
if (spec != specifications->end()) {
@@ -362,7 +362,7 @@
}
}
-string DwarfCUToModule::GenericDIEHandler::AddStringToPool(const string &str) {
+string DwarfCUToModule::GenericDIEHandler::AddStringToPool(const string& str) {
pair<unordered_set<string>::iterator, bool> result =
cu_context_->file_context->file_private_->common_strings.insert(str);
return *result.first;
@@ -371,7 +371,7 @@
void DwarfCUToModule::GenericDIEHandler::ProcessAttributeString(
enum DwarfAttribute attr,
enum DwarfForm form,
- const string &data) {
+ const string& data) {
switch (attr) {
case dwarf2reader::DW_AT_name:
name_attribute_ = AddStringToPool(data);
@@ -404,7 +404,7 @@
// Use the demangled name, if one is available. Demangled names are
// preferable to those inferred from the DWARF structure because they
// include argument types.
- const string *qualified_name = NULL;
+ const string* qualified_name = NULL;
if (!demangled_name_.empty()) {
// Found it is this DIE.
qualified_name = &demangled_name_;
@@ -413,8 +413,8 @@
qualified_name = &specification_->qualified_name;
}
- const string *unqualified_name = NULL;
- const string *enclosing_name;
+ const string* unqualified_name = NULL;
+ const string* enclosing_name;
if (!qualified_name) {
// Find the unqualified name. If the DIE has its own DW_AT_name
// attribute, then use that; otherwise, check the specification.
@@ -466,7 +466,7 @@
// A handler class for DW_TAG_subprogram DIEs.
class DwarfCUToModule::FuncHandler: public GenericDIEHandler {
public:
- FuncHandler(CUContext *cu_context, DIEContext *parent_context,
+ FuncHandler(CUContext* cu_context, DIEContext* parent_context,
uint64_t offset)
: GenericDIEHandler(cu_context, parent_context, offset),
low_pc_(0), high_pc_(0), high_pc_form_(dwarf2reader::DW_FORM_addr),
@@ -605,7 +605,7 @@
Module::Range range(low_pc_, high_pc_ - low_pc_);
ranges.push_back(range);
} else {
- RangesHandler *ranges_handler = cu_context_->ranges_handler;
+ RangesHandler* ranges_handler = cu_context_->ranges_handler;
if (ranges_handler) {
if (!ranges_handler->ReadRanges(ranges_, cu_context_->low_pc, &ranges)) {
@@ -668,11 +668,11 @@
// component to their names: namespaces, classes, etc.
class DwarfCUToModule::NamedScopeHandler: public GenericDIEHandler {
public:
- NamedScopeHandler(CUContext *cu_context, DIEContext *parent_context,
+ NamedScopeHandler(CUContext* cu_context, DIEContext* parent_context,
uint64_t offset)
: GenericDIEHandler(cu_context, parent_context, offset) { }
bool EndAttributes();
- DIEHandler *FindChildHandler(uint64_t offset, enum DwarfTag tag);
+ DIEHandler* FindChildHandler(uint64_t offset, enum DwarfTag tag);
private:
DIEContext child_context_; // A context for our children.
@@ -683,7 +683,7 @@
return true;
}
-dwarf2reader::DIEHandler *DwarfCUToModule::NamedScopeHandler::FindChildHandler(
+dwarf2reader::DIEHandler* DwarfCUToModule::NamedScopeHandler::FindChildHandler(
uint64_t offset,
enum DwarfTag tag) {
switch (tag) {
@@ -725,7 +725,7 @@
filename_.c_str(), offset, target);
}
-void DwarfCUToModule::WarningReporter::MissingSection(const string &name) {
+void DwarfCUToModule::WarningReporter::MissingSection(const string& name) {
CUHeading();
fprintf(stderr, "%s: warning: couldn't find DWARF '%s' section\n",
filename_.c_str(), name.c_str());
@@ -748,7 +748,7 @@
}
void DwarfCUToModule::WarningReporter::UncoveredFunction(
- const Module::Function &function) {
+ const Module::Function& function) {
if (!uncovered_warnings_enabled_)
return;
UncoveredHeading();
@@ -757,7 +757,7 @@
function.name.c_str());
}
-void DwarfCUToModule::WarningReporter::UncoveredLine(const Module::Line &line) {
+void DwarfCUToModule::WarningReporter::UncoveredLine(const Module::Line& line) {
if (!uncovered_warnings_enabled_)
return;
UncoveredHeading();
@@ -772,7 +772,7 @@
filename_.c_str(), offset);
}
-void DwarfCUToModule::WarningReporter::DemangleError(const string &input) {
+void DwarfCUToModule::WarningReporter::DemangleError(const string& input) {
CUHeading();
fprintf(stderr, "%s: warning: failed to demangle %s\n",
filename_.c_str(), input.c_str());
@@ -800,10 +800,10 @@
"the .debug_ranges section is missing.\n", filename_.c_str());
}
-DwarfCUToModule::DwarfCUToModule(FileContext *file_context,
- LineToModuleHandler *line_reader,
- RangesHandler *ranges_handler,
- WarningReporter *reporter)
+DwarfCUToModule::DwarfCUToModule(FileContext* file_context,
+ LineToModuleHandler* line_reader,
+ RangesHandler* ranges_handler,
+ WarningReporter* reporter)
: line_reader_(line_reader),
cu_context_(new CUContext(file_context, reporter, ranges_handler)),
child_context_(new DIEContext()),
@@ -853,7 +853,7 @@
void DwarfCUToModule::ProcessAttributeString(enum DwarfAttribute attr,
enum DwarfForm form,
- const string &data) {
+ const string& data) {
switch (attr) {
case dwarf2reader::DW_AT_name:
cu_context_->reporter->SetCUName(data);
@@ -870,7 +870,7 @@
return true;
}
-dwarf2reader::DIEHandler *DwarfCUToModule::FindChildHandler(
+dwarf2reader::DIEHandler* DwarfCUToModule::FindChildHandler(
uint64_t offset,
enum DwarfTag tag) {
switch (tag) {
@@ -932,7 +932,7 @@
}
void DwarfCUToModule::ReadSourceLines(uint64_t offset) {
- const dwarf2reader::SectionMap §ion_map
+ const dwarf2reader::SectionMap& section_map
= cu_context_->file_context->section_map();
dwarf2reader::SectionMap::const_iterator map_entry
= dwarf2reader::GetSectionByName(section_map, ".debug_line");
@@ -974,30 +974,30 @@
namespace {
class FunctionRange {
public:
- FunctionRange(const Module::Range &range, Module::Function *function) :
+ FunctionRange(const Module::Range& range, Module::Function* function) :
address(range.address), size(range.size), function(function) { }
- void AddLine(Module::Line &line) {
+ void AddLine(Module::Line& line) {
function->lines.push_back(line);
}
Module::Address address;
Module::Address size;
- Module::Function *function;
+ Module::Function* function;
};
// Fills an array of ranges with pointers to the functions which owns
// them. The array is sorted in ascending order and the ranges are non
// empty and non-overlapping.
-static void FillSortedFunctionRanges(vector<FunctionRange> &dest_ranges,
- vector<Module::Function *> *functions) {
- for (vector<Module::Function *>::const_iterator func_it = functions->cbegin();
+static void FillSortedFunctionRanges(vector<FunctionRange>& dest_ranges,
+ vector<Module::Function*>* functions) {
+ for (vector<Module::Function*>::const_iterator func_it = functions->cbegin();
func_it != functions->cend();
func_it++)
{
- Module::Function *func = *func_it;
- vector<Module::Range> &ranges = func->ranges;
+ Module::Function* func = *func_it;
+ vector<Module::Range>& ranges = func->ranges;
for (vector<Module::Range>::const_iterator ranges_it = ranges.cbegin();
ranges_it != ranges.cend();
++ranges_it) {
@@ -1009,7 +1009,7 @@
}
sort(dest_ranges.begin(), dest_ranges.end(),
- [](const FunctionRange &fr1, const FunctionRange &fr2) {
+ [](const FunctionRange& fr1, const FunctionRange& fr2) {
return fr1.address < fr2.address;
}
);
@@ -1017,7 +1017,7 @@
// Return true if ADDRESS falls within the range of ITEM.
template <class T>
-inline bool within(const T &item, Module::Address address) {
+inline bool within(const T& item, Module::Address address) {
// Because Module::Address is unsigned, and unsigned arithmetic
// wraps around, this will be false if ADDRESS falls before the
// start of ITEM, or if it falls after ITEM's end.
@@ -1026,8 +1026,8 @@
}
void DwarfCUToModule::AssignLinesToFunctions() {
- vector<Module::Function *> *functions = &cu_context_->functions;
- WarningReporter *reporter = cu_context_->reporter;
+ vector<Module::Function*>* functions = &cu_context_->functions;
+ WarningReporter* reporter = cu_context_->reporter;
// This would be simpler if we assumed that source line entries
// don't cross function boundaries. However, there's no real reason
@@ -1047,12 +1047,12 @@
// The last line that we used any piece of. We use this only for
// generating warnings.
- const Module::Line *last_line_used = NULL;
+ const Module::Line* last_line_used = NULL;
// The last function and line we warned about --- so we can avoid
// doing so more than once.
- const Module::Function *last_function_cited = NULL;
- const Module::Line *last_line_cited = NULL;
+ const Module::Function* last_function_cited = NULL;
+ const Module::Line* last_line_cited = NULL;
// Prepare a sorted list of ranges with range-to-function mapping
vector<FunctionRange> sorted_ranges;
@@ -1068,8 +1068,8 @@
// Pointers to the referents of func_it and line_it, or NULL if the
// iterator is at the end of the sequence.
- FunctionRange *range;
- const Module::Line *line;
+ FunctionRange* range;
+ const Module::Line* line;
// Start current at the beginning of the first line or function,
// whichever is earlier.
@@ -1232,7 +1232,7 @@
if (has_source_line_info_)
ReadSourceLines(source_line_offset_);
- vector<Module::Function *> *functions = &cu_context_->functions;
+ vector<Module::Function*>* functions = &cu_context_->functions;
// Dole out lines to the appropriate functions.
AssignLinesToFunctions();
diff --git a/src/common/dwarf_cu_to_module.h b/src/common/dwarf_cu_to_module.h
index b948aec..3e15b66 100644
--- a/src/common/dwarf_cu_to_module.h
+++ b/src/common/dwarf_cu_to_module.h
@@ -79,14 +79,14 @@
// to true to handle debugging symbols with DW_FORM_ref_addr entries.
class FileContext {
public:
- FileContext(const string &filename,
- Module *module,
+ FileContext(const string& filename,
+ Module* module,
bool handle_inter_cu_refs);
~FileContext();
// Add CONTENTS of size LENGTH to the section map as NAME.
void AddSectionToSectionMap(const string& name,
- const uint8_t *contents,
+ const uint8_t* contents,
uint64_t length);
// Clear the section map for testing.
@@ -114,7 +114,7 @@
dwarf2reader::SectionMap section_map_;
// The Module to which we're contributing definitions.
- Module *module_;
+ Module* module_;
// True if we are handling references between compilation units.
const bool handle_inter_cu_refs_;
@@ -163,7 +163,7 @@
uint64_t string_section_length,
const uint8_t* line_string_section,
uint64_t line_string_length,
- Module *module, vector<Module::Line> *lines) = 0;
+ Module* module, vector<Module::Line>* lines) = 0;
};
// The interface DwarfCUToModule uses to report warnings. The member
@@ -174,14 +174,14 @@
public:
// Warn about problems in the DWARF file FILENAME, in the
// compilation unit at OFFSET.
- WarningReporter(const string &filename, uint64_t cu_offset)
+ WarningReporter(const string& filename, uint64_t cu_offset)
: filename_(filename), cu_offset_(cu_offset), printed_cu_header_(false),
printed_unpaired_header_(false),
uncovered_warnings_enabled_(false) { }
virtual ~WarningReporter() { }
// Set the name of the compilation unit we're processing to NAME.
- virtual void SetCUName(const string &name) { cu_name_ = name; }
+ virtual void SetCUName(const string& name) { cu_name_ = name; }
// Accessor and setter for uncovered_warnings_enabled_.
// UncoveredFunction and UncoveredLine only report a problem if that is
@@ -204,17 +204,17 @@
virtual void UnknownAbstractOrigin(uint64_t offset, uint64_t target);
// We were unable to find the DWARF section named SECTION_NAME.
- virtual void MissingSection(const string §ion_name);
+ virtual void MissingSection(const string& section_name);
// The CU's DW_AT_stmt_list offset OFFSET is bogus.
virtual void BadLineInfoOffset(uint64_t offset);
// FUNCTION includes code covered by no line number data.
- virtual void UncoveredFunction(const Module::Function &function);
+ virtual void UncoveredFunction(const Module::Function& function);
// Line number NUMBER in LINE_FILE, of length LENGTH, includes code
// covered by no function.
- virtual void UncoveredLine(const Module::Line &line);
+ virtual void UncoveredLine(const Module::Line& line);
// The DW_TAG_subprogram DIE at OFFSET has no name specified directly
// in the DIE, nor via a DW_AT_specification or DW_AT_abstract_origin
@@ -222,7 +222,7 @@
virtual void UnnamedFunction(uint64_t offset);
// __cxa_demangle() failed to demangle INPUT.
- virtual void DemangleError(const string &input);
+ virtual void DemangleError(const string& input);
// The DW_FORM_ref_addr at OFFSET to TARGET was not handled because
// FilePrivate did not retain the inter-CU specification data.
@@ -261,10 +261,10 @@
// FILE_CONTEXT->module. Use LINE_READER to handle the compilation
// unit's line number data. Use REPORTER to report problems with the
// data we find.
- DwarfCUToModule(FileContext *file_context,
- LineToModuleHandler *line_reader,
- RangesHandler *ranges_handler,
- WarningReporter *reporter);
+ DwarfCUToModule(FileContext* file_context,
+ LineToModuleHandler* line_reader,
+ RangesHandler* ranges_handler,
+ WarningReporter* reporter);
~DwarfCUToModule();
void ProcessAttributeSigned(enum DwarfAttribute attr,
@@ -275,9 +275,9 @@
uint64_t data);
void ProcessAttributeString(enum DwarfAttribute attr,
enum DwarfForm form,
- const string &data);
+ const string& data);
bool EndAttributes();
- DIEHandler *FindChildHandler(uint64_t offset, enum DwarfTag tag);
+ DIEHandler* FindChildHandler(uint64_t offset, enum DwarfTag tag);
// Assign all our source Lines to the Functions that cover their
// addresses, and then add them to module_.
@@ -323,7 +323,7 @@
// destructor deletes them.
// The handler to use to handle line number data.
- LineToModuleHandler *line_reader_;
+ LineToModuleHandler* line_reader_;
// This compilation unit's context.
scoped_ptr<CUContext> cu_context_;
diff --git a/src/common/dwarf_cu_to_module_unittest.cc b/src/common/dwarf_cu_to_module_unittest.cc
index 1b7e2bf..8545c67 100644
--- a/src/common/dwarf_cu_to_module_unittest.cc
+++ b/src/common/dwarf_cu_to_module_unittest.cc
@@ -77,17 +77,17 @@
class MockWarningReporter: public DwarfCUToModule::WarningReporter {
public:
- MockWarningReporter(const string &filename, uint64_t cu_offset)
+ MockWarningReporter(const string& filename, uint64_t cu_offset)
: DwarfCUToModule::WarningReporter(filename, cu_offset) { }
- MOCK_METHOD1(SetCUName, void(const string &name));
+ MOCK_METHOD1(SetCUName, void(const string& name));
MOCK_METHOD2(UnknownSpecification, void(uint64_t offset, uint64_t target));
MOCK_METHOD2(UnknownAbstractOrigin, void(uint64_t offset, uint64_t target));
- MOCK_METHOD1(MissingSection, void(const string §ion_name));
+ MOCK_METHOD1(MissingSection, void(const string& section_name));
MOCK_METHOD1(BadLineInfoOffset, void(uint64_t offset));
- MOCK_METHOD1(UncoveredFunction, void(const Module::Function &function));
- MOCK_METHOD1(UncoveredLine, void(const Module::Line &line));
+ MOCK_METHOD1(UncoveredFunction, void(const Module::Function& function));
+ MOCK_METHOD1(UncoveredLine, void(const Module::Line& line));
MOCK_METHOD1(UnnamedFunction, void(uint64_t offset));
- MOCK_METHOD1(DemangleError, void(const string &input));
+ MOCK_METHOD1(DemangleError, void(const string& input));
MOCK_METHOD2(UnhandledInterCUReference, void(uint64_t offset, uint64_t target));
};
@@ -116,7 +116,7 @@
class AppendLinesFunctor {
public:
explicit AppendLinesFunctor(
- const vector<Module::Line> *lines) : lines_(lines) { }
+ const vector<Module::Line>* lines) : lines_(lines) { }
void operator()(const uint8_t* program, uint64_t length,
const uint8_t* string_section,
uint64_t string_section_length,
@@ -126,7 +126,7 @@
lines->insert(lines->end(), lines_->begin(), lines_->end());
}
private:
- const vector<Module::Line> *lines_;
+ const vector<Module::Line>* lines_;
};
CUFixtureBase()
@@ -169,7 +169,7 @@
// when it invokes its LineToModuleHandler. Call this before calling
// StartCU.
void PushLine(Module::Address address, Module::Address size,
- const string &filename, int line_number);
+ const string& filename, int line_number);
// Use LANGUAGE for the compilation unit. More precisely, arrange
// for StartCU to pass the compilation unit's root DIE a
@@ -190,28 +190,28 @@
void StartCU();
// Have HANDLER process some strange attribute/form/value triples.
- void ProcessStrangeAttributes(dwarf2reader::DIEHandler *handler);
+ void ProcessStrangeAttributes(dwarf2reader::DIEHandler* handler);
// Start a child DIE of PARENT with the given tag and name. Leave
// the handler ready to hear about children: call EndAttributes, but
// not Finish.
- DIEHandler *StartNamedDIE(DIEHandler *parent, DwarfTag tag,
- const string &name);
+ DIEHandler* StartNamedDIE(DIEHandler* parent, DwarfTag tag,
+ const string& name);
// Start a child DIE of PARENT with the given tag and a
// DW_AT_specification attribute whose value is SPECIFICATION. Leave
// the handler ready to hear about children: call EndAttributes, but
// not Finish. If NAME is non-zero, use it as the DW_AT_name
// attribute.
- DIEHandler *StartSpecifiedDIE(DIEHandler *parent, DwarfTag tag,
- uint64_t specification, const char *name = NULL);
+ DIEHandler* StartSpecifiedDIE(DIEHandler* parent, DwarfTag tag,
+ uint64_t specification, const char* name = NULL);
// Define a function as a child of PARENT with the given name, address, and
// size. If high_pc_form is DW_FORM_addr then the DW_AT_high_pc attribute
// will be written as an address; otherwise it will be written as the
// function's size. Call EndAttributes and Finish; one cannot define
// children of the defined function's DIE.
- void DefineFunction(DIEHandler *parent, const string &name,
+ void DefineFunction(DIEHandler* parent, const string& name,
Module::Address address, Module::Address size,
const char* mangled_name,
DwarfForm high_pc_form = dwarf2reader::DW_FORM_addr);
@@ -219,32 +219,32 @@
// Create a declaration DIE as a child of PARENT with the given
// offset, tag and name. If NAME is the empty string, don't provide
// a DW_AT_name attribute. Call EndAttributes and Finish.
- void DeclarationDIE(DIEHandler *parent, uint64_t offset,
- DwarfTag tag, const string &name,
- const string &mangled_name);
+ void DeclarationDIE(DIEHandler* parent, uint64_t offset,
+ DwarfTag tag, const string& name,
+ const string& mangled_name);
// Create a definition DIE as a child of PARENT with the given tag
// that refers to the declaration DIE at offset SPECIFICATION as its
// specification. If NAME is non-empty, pass it as the DW_AT_name
// attribute. If SIZE is non-zero, record ADDRESS and SIZE as
// low_pc/high_pc attributes.
- void DefinitionDIE(DIEHandler *parent, DwarfTag tag,
- uint64_t specification, const string &name,
+ void DefinitionDIE(DIEHandler* parent, DwarfTag tag,
+ uint64_t specification, const string& name,
Module::Address address = 0, Module::Address size = 0);
// Create an inline DW_TAG_subprogram DIE as a child of PARENT. If
// SPECIFICATION is non-zero, then the DIE refers to the declaration DIE at
// offset SPECIFICATION as its specification. If Name is non-empty, pass it
// as the DW_AT_name attribute.
- void AbstractInstanceDIE(DIEHandler *parent, uint64_t offset,
+ void AbstractInstanceDIE(DIEHandler* parent, uint64_t offset,
DwarfInline type, uint64_t specification,
- const string &name,
+ const string& name,
DwarfForm form = dwarf2reader::DW_FORM_data1);
// Create a DW_TAG_subprogram DIE as a child of PARENT that refers to
// ORIGIN in its DW_AT_abstract_origin attribute. If NAME is the empty
// string, don't provide a DW_AT_name attribute.
- void DefineInlineInstanceDIE(DIEHandler *parent, const string &name,
+ void DefineInlineInstanceDIE(DIEHandler* parent, const string& name,
uint64_t origin, Module::Address address,
Module::Address size);
@@ -259,7 +259,7 @@
// Test that the I'th function (ordered by address) in the module
// this.module_ has the given name, address, and size, and that its
// parameter size is zero.
- void TestFunction(int i, const string &name,
+ void TestFunction(int i, const string& name,
Module::Address address, Module::Address size);
// Test that the number of source lines owned by the I'th function
@@ -270,7 +270,7 @@
// (again, by address) has the given address, size, filename, and
// line number.
void TestLine(int i, int j, Module::Address address, Module::Address size,
- const string &filename, int number);
+ const string& filename, int number);
// Actual objects under test.
Module module_;
@@ -308,7 +308,7 @@
// If functions_filled_ is true, this is a table of functions we've
// extracted from module_, sorted by address.
- vector<Module::Function *> functions_;
+ vector<Module::Function*> functions_;
// True if we have filled the above vector with this.module_'s function list.
bool functions_filled_;
};
@@ -318,7 +318,7 @@
sizeof(CUFixtureBase::dummy_line_program_);
void CUFixtureBase::PushLine(Module::Address address, Module::Address size,
- const string &filename, int line_number) {
+ const string& filename, int line_number) {
Module::Line l;
l.address = address;
l.size = size;
@@ -376,7 +376,7 @@
}
void CUFixtureBase::ProcessStrangeAttributes(
- dwarf2reader::DIEHandler *handler) {
+ dwarf2reader::DIEHandler* handler) {
handler->ProcessAttributeUnsigned((DwarfAttribute) 0xf560dead,
(DwarfForm) 0x4106e4db,
0xa592571997facda1ULL);
@@ -395,10 +395,10 @@
"strange string");
}
-DIEHandler *CUFixtureBase::StartNamedDIE(DIEHandler *parent,
+DIEHandler* CUFixtureBase::StartNamedDIE(DIEHandler* parent,
DwarfTag tag,
- const string &name) {
- dwarf2reader::DIEHandler *handler
+ const string& name) {
+ dwarf2reader::DIEHandler* handler
= parent->FindChildHandler(0x8f4c783c0467c989ULL, tag);
if (!handler)
return NULL;
@@ -415,11 +415,11 @@
return handler;
}
-DIEHandler *CUFixtureBase::StartSpecifiedDIE(DIEHandler *parent,
+DIEHandler* CUFixtureBase::StartSpecifiedDIE(DIEHandler* parent,
DwarfTag tag,
uint64_t specification,
- const char *name) {
- dwarf2reader::DIEHandler *handler
+ const char* name) {
+ dwarf2reader::DIEHandler* handler
= parent->FindChildHandler(0x8f4c783c0467c989ULL, tag);
if (!handler)
return NULL;
@@ -439,12 +439,12 @@
return handler;
}
-void CUFixtureBase::DefineFunction(dwarf2reader::DIEHandler *parent,
- const string &name, Module::Address address,
+void CUFixtureBase::DefineFunction(dwarf2reader::DIEHandler* parent,
+ const string& name, Module::Address address,
Module::Address size,
const char* mangled_name,
DwarfForm high_pc_form) {
- dwarf2reader::DIEHandler *func
+ dwarf2reader::DIEHandler* func
= parent->FindChildHandler(0xe34797c7e68590a8LL,
dwarf2reader::DW_TAG_subprogram);
ASSERT_TRUE(func != NULL);
@@ -474,11 +474,11 @@
delete func;
}
-void CUFixtureBase::DeclarationDIE(DIEHandler *parent, uint64_t offset,
+void CUFixtureBase::DeclarationDIE(DIEHandler* parent, uint64_t offset,
DwarfTag tag,
- const string &name,
- const string &mangled_name) {
- dwarf2reader::DIEHandler *die = parent->FindChildHandler(offset, tag);
+ const string& name,
+ const string& mangled_name) {
+ dwarf2reader::DIEHandler* die = parent->FindChildHandler(offset, tag);
ASSERT_TRUE(die != NULL);
if (!name.empty())
die->ProcessAttributeString(dwarf2reader::DW_AT_name,
@@ -497,13 +497,13 @@
delete die;
}
-void CUFixtureBase::DefinitionDIE(DIEHandler *parent,
+void CUFixtureBase::DefinitionDIE(DIEHandler* parent,
DwarfTag tag,
uint64_t specification,
- const string &name,
+ const string& name,
Module::Address address,
Module::Address size) {
- dwarf2reader::DIEHandler *die
+ dwarf2reader::DIEHandler* die
= parent->FindChildHandler(0x6ccfea031a9e6cc9ULL, tag);
ASSERT_TRUE(die != NULL);
die->ProcessAttributeReference(dwarf2reader::DW_AT_specification,
@@ -526,13 +526,13 @@
delete die;
}
-void CUFixtureBase::AbstractInstanceDIE(DIEHandler *parent,
+void CUFixtureBase::AbstractInstanceDIE(DIEHandler* parent,
uint64_t offset,
DwarfInline type,
uint64_t specification,
- const string &name,
+ const string& name,
DwarfForm form) {
- dwarf2reader::DIEHandler *die
+ dwarf2reader::DIEHandler* die
= parent->FindChildHandler(offset, dwarf2reader::DW_TAG_subprogram);
ASSERT_TRUE(die != NULL);
if (specification != 0ULL)
@@ -554,12 +554,12 @@
delete die;
}
-void CUFixtureBase::DefineInlineInstanceDIE(DIEHandler *parent,
- const string &name,
+void CUFixtureBase::DefineInlineInstanceDIE(DIEHandler* parent,
+ const string& name,
uint64_t origin,
Module::Address address,
Module::Address size) {
- dwarf2reader::DIEHandler *func
+ dwarf2reader::DIEHandler* func
= parent->FindChildHandler(0x11c70f94c6e87ccdLL,
dwarf2reader::DW_TAG_subprogram);
ASSERT_TRUE(func != NULL);
@@ -597,13 +597,13 @@
ASSERT_EQ(expected, functions_.size());
}
-void CUFixtureBase::TestFunction(int i, const string &name,
+void CUFixtureBase::TestFunction(int i, const string& name,
Module::Address address,
Module::Address size) {
FillFunctions();
ASSERT_LT((size_t) i, functions_.size());
- Module::Function *function = functions_[i];
+ Module::Function* function = functions_[i];
EXPECT_EQ(name, function->name);
EXPECT_EQ(address, function->address);
EXPECT_EQ(size, function->ranges[0].size);
@@ -619,12 +619,12 @@
void CUFixtureBase::TestLine(int i, int j,
Module::Address address, Module::Address size,
- const string &filename, int number) {
+ const string& filename, int number) {
FillFunctions();
ASSERT_LT((size_t) i, functions_.size());
ASSERT_LT((size_t) j, functions_[i]->lines.size());
- Module::Line *line = &functions_[i]->lines[j];
+ Module::Line* line = &functions_[i]->lines[j];
EXPECT_EQ(address, line->address);
EXPECT_EQ(size, line->size);
EXPECT_EQ(filename, line->file->name.c_str());
@@ -711,7 +711,7 @@
TEST_F(SimpleCU, IrrelevantNamedScopeChildren) {
StartCU();
- DIEHandler *class_A_handler
+ DIEHandler* class_A_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type, "class_A");
EXPECT_TRUE(class_A_handler != NULL);
EXPECT_FALSE(class_A_handler
@@ -861,7 +861,7 @@
ValuesIn(situations));
TEST_P(FuncLinePairing, Pairing) {
- const Situation &s = GetParam();
+ const Situation& s = GetParam();
PushLine(s.lines[0].start,
s.lines[0].end - s.lines[0].start,
"line-file", 67636963);
@@ -1057,7 +1057,7 @@
PushLine(20, 1, "filename2", 95115701);
StartCU();
- DIEHandler *enclosure_handler = StartNamedDIE(&root_handler_, tag,
+ DIEHandler* enclosure_handler = StartNamedDIE(&root_handler_, tag,
"Enclosure");
EXPECT_TRUE(enclosure_handler != NULL);
DefineFunction(enclosure_handler, "func_B", 10, 1, NULL);
@@ -1078,11 +1078,11 @@
PushLine(10, 1, "line-file", 69819327);
StartCU();
- DIEHandler *namespace_handler
+ DIEHandler* namespace_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_namespace,
"Namespace");
EXPECT_TRUE(namespace_handler != NULL);
- DIEHandler *enclosure_handler = StartNamedDIE(namespace_handler, tag,
+ DIEHandler* enclosure_handler = StartNamedDIE(namespace_handler, tag,
"Enclosure");
EXPECT_TRUE(enclosure_handler != NULL);
DefineFunction(enclosure_handler, "function", 10, 1, NULL);
@@ -1101,15 +1101,15 @@
PushLine(10, 1, "filename1", 69819327);
StartCU();
- DIEHandler *namespace_handler
+ DIEHandler* namespace_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_namespace,
"namespace_A");
EXPECT_TRUE(namespace_handler != NULL);
- DIEHandler *struct_handler
+ DIEHandler* struct_handler
= StartNamedDIE(namespace_handler, dwarf2reader::DW_TAG_structure_type,
"struct_B");
EXPECT_TRUE(struct_handler != NULL);
- DIEHandler *class_handler
+ DIEHandler* class_handler
= StartNamedDIE(struct_handler, dwarf2reader::DW_TAG_class_type,
"class_C");
DefineFunction(class_handler, "function_D", 10, 1, NULL);
@@ -1127,7 +1127,7 @@
struct LanguageAndQualifiedName {
dwarf2reader::DwarfLanguage language;
- const char *name;
+ const char* name;
};
const LanguageAndQualifiedName LanguageAndQualifiedNameCases[] = {
@@ -1149,13 +1149,13 @@
ValuesIn(LanguageAndQualifiedNameCases));
TEST_P(QualifiedForLanguage, MemberFunction) {
- const LanguageAndQualifiedName ¶m = GetParam();
+ const LanguageAndQualifiedName& param = GetParam();
PushLine(10, 1, "line-file", 212966758);
SetLanguage(param.language);
StartCU();
- DIEHandler *class_handler
+ DIEHandler* class_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
"class_A");
DefineFunction(class_handler, "function_B", 10, 1, NULL);
@@ -1172,14 +1172,14 @@
}
TEST_P(QualifiedForLanguage, MemberFunctionSignedLanguage) {
- const LanguageAndQualifiedName ¶m = GetParam();
+ const LanguageAndQualifiedName& param = GetParam();
PushLine(10, 1, "line-file", 212966758);
SetLanguage(param.language);
SetLanguageSigned(true);
StartCU();
- DIEHandler *class_handler
+ DIEHandler* class_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
"class_A");
DefineFunction(class_handler, "function_B", 10, 1, NULL);
@@ -1282,7 +1282,7 @@
PushLine(0x3341a248634e7170ULL, 0x5f6938ee5553b953ULL, "line-file", 18116691);
StartCU();
- DIEHandler *class_handler
+ DIEHandler* class_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type, "class_A");
DeclarationDIE(class_handler, 0x7d83028c431406e8ULL,
dwarf2reader::DW_TAG_subprogram, "declaration-name", "");
@@ -1305,7 +1305,7 @@
StartCU();
{
- DIEHandler *class_handler
+ DIEHandler* class_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
"class_A");
ASSERT_TRUE(class_handler != NULL);
@@ -1333,7 +1333,7 @@
StartCU();
{
- DIEHandler *space_handler
+ DIEHandler* space_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_namespace,
"space_A");
ASSERT_TRUE(space_handler != NULL);
@@ -1345,7 +1345,7 @@
}
{
- DIEHandler *class_handler
+ DIEHandler* class_handler
= StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
0x419bb1d12f9a73a2ULL, "class-definition-name");
ASSERT_TRUE(class_handler != NULL);
@@ -1437,7 +1437,7 @@
// space_A::space_B::struct_C::struct_D::union_E::union_F::
// class_G::class_H::func_I
{
- DIEHandler *space_A_handler
+ DIEHandler* space_A_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_namespace,
"space_A");
DeclarationDIE(space_A_handler, 0x2e111126496596e2ULL,
@@ -1447,10 +1447,10 @@
}
{
- DIEHandler *space_B_handler
+ DIEHandler* space_B_handler
= StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_namespace,
0x2e111126496596e2ULL);
- DIEHandler *struct_C_handler
+ DIEHandler* struct_C_handler
= StartNamedDIE(space_B_handler, dwarf2reader::DW_TAG_structure_type,
"struct_C");
DeclarationDIE(struct_C_handler, 0x20cd423bf2a25a4cULL,
@@ -1462,10 +1462,10 @@
}
{
- DIEHandler *struct_D_handler
+ DIEHandler* struct_D_handler
= StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_structure_type,
0x20cd423bf2a25a4cULL);
- DIEHandler *union_E_handler
+ DIEHandler* union_E_handler
= StartNamedDIE(struct_D_handler, dwarf2reader::DW_TAG_union_type,
"union_E");
DeclarationDIE(union_E_handler, 0xe25c84805aa58c32ULL,
@@ -1477,10 +1477,10 @@
}
{
- DIEHandler *union_F_handler
+ DIEHandler* union_F_handler
= StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_union_type,
0xe25c84805aa58c32ULL);
- DIEHandler *class_G_handler
+ DIEHandler* class_G_handler
= StartNamedDIE(union_F_handler, dwarf2reader::DW_TAG_class_type,
"class_G");
DeclarationDIE(class_G_handler, 0xb70d960dcc173b6eULL,
@@ -1492,7 +1492,7 @@
}
{
- DIEHandler *class_H_handler
+ DIEHandler* class_H_handler
= StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
0xb70d960dcc173b6eULL);
DeclarationDIE(class_H_handler, 0x27ff829e3bf69f37ULL,
@@ -1542,7 +1542,7 @@
ASSERT_TRUE(root2_handler.StartRootDIE(1,
dwarf2reader::DW_TAG_compile_unit));
ASSERT_TRUE(root2_handler.EndAttributes());
- DIEHandler *class_A_handler
+ DIEHandler* class_A_handler
= StartSpecifiedDIE(&root2_handler, dwarf2reader::DW_TAG_class_type,
0xb8fbfdd5f0b26fceULL);
DeclarationDIE(class_A_handler, 0xb01fef8b380bd1a2ULL,
@@ -1565,7 +1565,7 @@
root3_handler.Finish();
}
- vector<Module::Function *> functions;
+ vector<Module::Function*> functions;
m.GetFunctions(&functions, functions.end());
EXPECT_EQ(1U, functions.size());
EXPECT_STREQ("class_A::member_func_B", functions[0]->name.c_str());
@@ -1602,7 +1602,7 @@
dwarf2reader::DW_TAG_compile_unit));
ASSERT_TRUE(root2_handler.EndAttributes());
EXPECT_CALL(reporter_, UnhandledInterCUReference(_, _)).Times(1);
- DIEHandler *class_A_handler
+ DIEHandler* class_A_handler
= StartSpecifiedDIE(&root2_handler, dwarf2reader::DW_TAG_class_type,
0xb8fbfdd5f0b26fceULL);
DeclarationDIE(class_A_handler, 0xb01fef8b380bd1a2ULL,
@@ -1665,7 +1665,7 @@
DeclarationDIE(&root_handler_, 0xd0fe467ec2f1a58cULL,
dwarf2reader::DW_TAG_class_type, "class-declaration-name", "");
- dwarf2reader::DIEHandler *class_definition
+ dwarf2reader::DIEHandler* class_definition
= StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
0xd0fe467ec2f1a58cULL, "class-definition-name");
ASSERT_TRUE(class_definition);
@@ -1696,7 +1696,7 @@
StartCU();
{
- dwarf2reader::DIEHandler *declaration_class_handler =
+ dwarf2reader::DIEHandler* declaration_class_handler =
StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
"declaration-class");
DeclarationDIE(declaration_class_handler, 0x9ddb35517455ef7aULL,
@@ -1706,7 +1706,7 @@
delete declaration_class_handler;
}
{
- dwarf2reader::DIEHandler *definition_class_handler
+ dwarf2reader::DIEHandler* definition_class_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
"definition-class");
DefinitionDIE(definition_class_handler, dwarf2reader::DW_TAG_subprogram,
diff --git a/src/common/dwarf_line_to_module.cc b/src/common/dwarf_line_to_module.cc
index 443d744..fe808c0 100644
--- a/src/common/dwarf_line_to_module.cc
+++ b/src/common/dwarf_line_to_module.cc
@@ -44,18 +44,18 @@
// it until we actually have to deal with DWARF on Windows.
// Return true if PATH is an absolute path, false if it is relative.
-static bool PathIsAbsolute(const string &path) {
+static bool PathIsAbsolute(const string& path) {
return (path.size() >= 1 && path[0] == '/');
}
-static bool HasTrailingSlash(const string &path) {
+static bool HasTrailingSlash(const string& path) {
return (path.size() >= 1 && path[path.size() - 1] == '/');
}
// If PATH is an absolute path, return PATH. If PATH is a relative path,
// treat it as relative to BASE and return the combined path.
-static string ExpandPath(const string &path,
- const string &base) {
+static string ExpandPath(const string& path,
+ const string& base) {
if (PathIsAbsolute(path) || base.empty())
return path;
return base + (HasTrailingSlash(base) ? "" : "/") + path;
@@ -63,14 +63,14 @@
namespace google_breakpad {
-void DwarfLineToModule::DefineDir(const string &name, uint32_t dir_num) {
+void DwarfLineToModule::DefineDir(const string& name, uint32_t dir_num) {
// Directory number zero is reserved to mean the compilation
// directory. Silently ignore attempts to redefine it.
if (dir_num != 0)
directories_[dir_num] = ExpandPath(name, compilation_dir_);
}
-void DwarfLineToModule::DefineFile(const string &name, int32_t file_num,
+void DwarfLineToModule::DefineFile(const string& name, int32_t file_num,
uint32_t dir_num, uint64_t mod_time,
uint64_t length) {
if (file_num == -1)
diff --git a/src/common/dwarf_line_to_module.h b/src/common/dwarf_line_to_module.h
index f54ccaf..f80f1b0 100644
--- a/src/common/dwarf_line_to_module.h
+++ b/src/common/dwarf_line_to_module.h
@@ -121,7 +121,7 @@
// sort out which lines belong to which functions; we don't add them
// to any particular function in MODULE ourselves.
DwarfLineToModule(Module *module, const string& compilation_dir,
- vector<Module::Line> *lines)
+ vector<Module::Line>* lines)
: module_(module),
compilation_dir_(compilation_dir),
lines_(lines),
@@ -132,8 +132,8 @@
~DwarfLineToModule() { }
- void DefineDir(const string &name, uint32_t dir_num);
- void DefineFile(const string &name, int32_t file_num,
+ void DefineDir(const string& name, uint32_t dir_num);
+ void DefineFile(const string& name, int32_t file_num,
uint32_t dir_num, uint64_t mod_time,
uint64_t length);
void AddLine(uint64_t address, uint64_t length,
@@ -142,7 +142,7 @@
private:
typedef std::map<uint32_t, string> DirectoryTable;
- typedef std::map<uint32_t, Module::File *> FileTable;
+ typedef std::map<uint32_t, Module::File*> FileTable;
// The module we're contributing debugging info to. Owned by our
// client.
@@ -161,7 +161,7 @@
// to the appropriate function from module_ until we've read the
// function info as well. Instead, we accumulate lines here, and let
// whoever constructed this sort it all out.
- vector<Module::Line> *lines_;
+ vector<Module::Line>* lines_;
// A table mapping directory numbers to paths.
DirectoryTable directories_;
diff --git a/src/common/dwarf_line_to_module_unittest.cc b/src/common/dwarf_line_to_module_unittest.cc
index 7c0fcfd..90b6570 100644
--- a/src/common/dwarf_line_to_module_unittest.cc
+++ b/src/common/dwarf_line_to_module_unittest.cc
@@ -51,7 +51,7 @@
h.AddLine(0x6fd126fbf74f2680LL, 0x63c9a14cf556712bLL, 0x30bf0f27,
0x4c090cbf, 0x1cf9fe0d);
- vector<Module::File *> files;
+ vector<Module::File*> files;
m.GetFiles(&files);
EXPECT_EQ(1U, files.size());
EXPECT_STREQ("/file1", files[0]->name.c_str());
@@ -86,7 +86,7 @@
h.AddLine(0xe2d72a37f8d9403aULL, 0x034dfab5b0d4d236ULL, 0x63beb4a5,
0x75047044U, 0xb6a0016cU);
- vector<Module::File *> files;
+ vector<Module::File*> files;
m.GetFiles(&files);
ASSERT_EQ(5U, files.size());
EXPECT_STREQ("/directory1/file1", files[0]->name.c_str());
@@ -133,7 +133,7 @@
h.AddLine(1, 1, 1, 0, 0);
- vector<Module::File *> files;
+ vector<Module::File*> files;
m.GetFiles(&files);
ASSERT_EQ(1U, files.size());
EXPECT_STREQ("/absolute", files[0]->name.c_str());
@@ -151,7 +151,7 @@
h.AddLine(1, 1, 1, 0, 0);
- vector<Module::File *> files;
+ vector<Module::File*> files;
m.GetFiles(&files);
ASSERT_EQ(1U, files.size());
EXPECT_STREQ("/directory1/relative", files[0]->name.c_str());
diff --git a/src/common/dwarf_range_list_handler.cc b/src/common/dwarf_range_list_handler.cc
index cc9e39c..58982aa 100644
--- a/src/common/dwarf_range_list_handler.cc
+++ b/src/common/dwarf_range_list_handler.cc
@@ -51,7 +51,7 @@
void DwarfRangeListHandler::Finish() {
std::sort(ranges_->begin(), ranges_->end(),
- [](const Module::Range &a, const Module::Range &b) {
+ [](const Module::Range& a, const Module::Range& b) {
return a.address < b.address;
}
);
diff --git a/src/common/dwarf_range_list_handler.h b/src/common/dwarf_range_list_handler.h
index 83a3469..2adb2f9 100644
--- a/src/common/dwarf_range_list_handler.h
+++ b/src/common/dwarf_range_list_handler.h
@@ -51,7 +51,7 @@
class DwarfRangeListHandler: public dwarf2reader::RangeListHandler {
public:
- DwarfRangeListHandler(uint64_t base_address, vector<Module::Range> *ranges)
+ DwarfRangeListHandler(uint64_t base_address, vector<Module::Range>* ranges)
: base_address_(base_address), ranges_(ranges) { }
~DwarfRangeListHandler() { }
@@ -71,7 +71,7 @@
uint64_t base_address_;
// The list of ranges to be populated
- vector<Module::Range> *ranges_;
+ vector<Module::Range>* ranges_;
};
} // namespace google_breakpad
diff --git a/src/common/language.cc b/src/common/language.cc
index 440d4de..381c8bd 100644
--- a/src/common/language.cc
+++ b/src/common/language.cc
@@ -67,8 +67,8 @@
public:
CPPLanguage() {}
- string MakeQualifiedName(const string &parent_name,
- const string &name) const {
+ string MakeQualifiedName(const string& parent_name,
+ const string& name) const {
return MakeQualifiedNameWithSeparator(parent_name, "::", name);
}
@@ -108,7 +108,7 @@
}
private:
- static bool IsMangledName(const string &name) {
+ static bool IsMangledName(const string& name) {
// NOTE: For proper cross-compilation support, this should depend on target
// binary's platform, not current build platform.
#if defined(__APPLE__)
@@ -130,8 +130,8 @@
public:
JavaLanguage() {}
- string MakeQualifiedName(const string &parent_name,
- const string &name) const {
+ string MakeQualifiedName(const string& parent_name,
+ const string& name) const {
return MakeQualifiedNameWithSeparator(parent_name, ".", name);
}
};
@@ -143,8 +143,8 @@
public:
SwiftLanguage() {}
- string MakeQualifiedName(const string &parent_name,
- const string &name) const {
+ string MakeQualifiedName(const string& parent_name,
+ const string& name) const {
return MakeQualifiedNameWithSeparator(parent_name, ".", name);
}
@@ -167,8 +167,8 @@
public:
RustLanguage() {}
- string MakeQualifiedName(const string &parent_name,
- const string &name) const {
+ string MakeQualifiedName(const string& parent_name,
+ const string& name) const {
return MakeQualifiedNameWithSeparator(parent_name, ".", name);
}
@@ -202,8 +202,8 @@
AssemblerLanguage() {}
bool HasFunctions() const { return false; }
- string MakeQualifiedName(const string &parent_name,
- const string &name) const {
+ string MakeQualifiedName(const string& parent_name,
+ const string& name) const {
return name;
}
};
diff --git a/src/common/language.h b/src/common/language.h
index 2d2dbcd..892ea86 100644
--- a/src/common/language.h
+++ b/src/common/language.h
@@ -74,8 +74,8 @@
// take into account the parent and child DIE types, allow languages
// to use their own data type for complex parent names, etc. But if
// C++ doesn't need all that, who would?
- virtual string MakeQualifiedName (const string &parent_name,
- const string &name) const = 0;
+ virtual string MakeQualifiedName (const string& parent_name,
+ const string& name) const = 0;
enum DemangleResult {
// Demangling was not performed because it’s not appropriate to attempt.
diff --git a/src/common/linux/breakpad_getcontext.S b/src/common/linux/breakpad_getcontext.S
index fea0109..528dba7 100644
--- a/src/common/linux/breakpad_getcontext.S
+++ b/src/common/linux/breakpad_getcontext.S
@@ -32,7 +32,7 @@
#include "common/linux/ucontext_constants.h"
-/* int getcontext (ucontext_t *ucp) */
+/* int getcontext (ucontext_t* ucp) */
#if defined(__arm__)
@@ -336,7 +336,7 @@
.size function,.-function
#endif
-/* int getcontext (ucontext_t *ucp) */
+/* int getcontext (ucontext_t* ucp) */
NESTED (breakpad_getcontext, FRAME_SIZE, ra)
.mask 0x10000000, 0
diff --git a/src/common/linux/dump_symbols.cc b/src/common/linux/dump_symbols.cc
index 997977b..8ecf0bc 100644
--- a/src/common/linux/dump_symbols.cc
+++ b/src/common/linux/dump_symbols.cc
@@ -144,7 +144,7 @@
munmap(base_, size_);
}
}
- void set(void *mapped_address, size_t mapped_size) {
+ void set(void* mapped_address, size_t mapped_size) {
is_set_ = true;
base_ = mapped_address;
size_ = mapped_size;
@@ -232,7 +232,7 @@
// owned by a function) with the results.
class DumperRangesHandler : public DwarfCUToModule::RangesHandler {
public:
- DumperRangesHandler(const uint8_t *buffer, uint64_t size,
+ DumperRangesHandler(const uint8_t* buffer, uint64_t size,
dwarf2reader::ByteReader* reader)
: buffer_(buffer), size_(size), reader_(reader) { }
@@ -246,7 +246,7 @@
}
private:
- const uint8_t *buffer_;
+ const uint8_t* buffer_;
uint64_t size_;
dwarf2reader::ByteReader* reader_;
};
@@ -257,7 +257,7 @@
class DumperLineToModule: public DwarfCUToModule::LineToModuleHandler {
public:
// Create a line-to-module converter using BYTE_READER.
- explicit DumperLineToModule(dwarf2reader::ByteReader *byte_reader)
+ explicit DumperLineToModule(dwarf2reader::ByteReader* byte_reader)
: byte_reader_(byte_reader) { }
void StartCompilationUnit(const string& compilation_dir) {
compilation_dir_ = compilation_dir;
@@ -278,7 +278,7 @@
}
private:
string compilation_dir_;
- dwarf2reader::ByteReader *byte_reader_;
+ dwarf2reader::ByteReader* byte_reader_;
};
template<typename ElfClass>
@@ -308,7 +308,7 @@
string name = GetOffset<ElfClass, char>(elf_header,
section_names->sh_offset) +
section->sh_name;
- const uint8_t *contents = GetOffset<ElfClass, uint8_t>(elf_header,
+ const uint8_t* contents = GetOffset<ElfClass, uint8_t>(elf_header,
section->sh_offset);
file_context.AddSectionToSectionMap(name, contents, section->sh_size);
}
@@ -318,7 +318,7 @@
dwarf2reader::SectionMap::const_iterator ranges_entry =
file_context.section_map().find(".debug_ranges");
if (ranges_entry != file_context.section_map().end()) {
- const std::pair<const uint8_t *, uint64_t>& ranges_section =
+ const std::pair<const uint8_t*, uint64_t>& ranges_section =
ranges_entry->second;
ranges_handler.reset(
new DumperRangesHandler(ranges_section.first, ranges_section.second,
@@ -330,7 +330,7 @@
dwarf2reader::SectionMap::const_iterator debug_info_entry =
file_context.section_map().find(".debug_info");
assert(debug_info_entry != file_context.section_map().end());
- const std::pair<const uint8_t *, uint64_t>& debug_info_section =
+ const std::pair<const uint8_t*, uint64_t>& debug_info_section =
debug_info_entry->second;
// This should never have been called if the file doesn't have a
// .debug_info section.
@@ -409,7 +409,7 @@
dwarf2reader::ENDIANNESS_BIG : dwarf2reader::ENDIANNESS_LITTLE;
// Find the call frame information and its size.
- const uint8_t *cfi =
+ const uint8_t* cfi =
GetOffset<ElfClass, uint8_t>(elf_header, section->sh_offset);
size_t cfi_size = section->sh_size;
@@ -497,13 +497,13 @@
// Read the .gnu_debuglink and get the debug file name. If anything goes
// wrong, return an empty string.
-string ReadDebugLink(const uint8_t *debuglink,
+string ReadDebugLink(const uint8_t* debuglink,
const size_t debuglink_size,
const bool big_endian,
const string& obj_file,
const std::vector<string>& debug_dirs) {
// Include '\0' + CRC32 (4 bytes).
- size_t debuglink_len = strlen(reinterpret_cast<const char *>(debuglink)) + 5;
+ size_t debuglink_len = strlen(reinterpret_cast<const char*>(debuglink)) + 5;
debuglink_len = 4 * ((debuglink_len + 3) / 4); // Round up to 4 bytes.
// Sanity check.
@@ -525,7 +525,7 @@
for (it = debug_dirs.begin(); it < debug_dirs.end(); ++it) {
const string& debug_dir = *it;
debuglink_path = debug_dir + "/" +
- reinterpret_cast<const char *>(debuglink);
+ reinterpret_cast<const char*>(debuglink);
// There is the annoying case of /path/to/foo.so having foo.so as the
// debug link file name. Thus this may end up opening /path/to/foo.so again,
@@ -599,7 +599,7 @@
// Keeps track of which sections have been loaded so sections don't
// accidentally get loaded twice from two different files.
- void LoadedSection(const string §ion) {
+ void LoadedSection(const string& section) {
if (loaded_sections_.count(section) == 0) {
loaded_sections_.insert(section);
} else {
@@ -610,7 +610,7 @@
// The ELF file and linked debug file are expected to have the same preferred
// loading address.
- void set_loading_addr(Addr addr, const string &filename) {
+ void set_loading_addr(Addr addr, const string& filename) {
if (!has_loading_addr_) {
loading_addr_ = addr;
loaded_file_ = filename;
@@ -687,7 +687,7 @@
const Shdr* section_names = sections + elf_header->e_shstrndx;
const char* names =
GetOffset<ElfClass, char>(elf_header, section_names->sh_offset);
- const char *names_end = names + section_names->sh_size;
+ const char* names_end = names + section_names->sh_size;
bool found_debug_info_section = false;
bool found_usable_info = false;
@@ -867,7 +867,7 @@
names_end, elf_header->e_shnum);
if (gnu_debuglink_section) {
if (!info->debug_dirs().empty()) {
- const uint8_t *debuglink_contents =
+ const uint8_t* debuglink_contents =
GetOffset<ElfClass, uint8_t>(elf_header,
gnu_debuglink_section->sh_offset);
string debuglink_file =
@@ -964,7 +964,7 @@
return false;
}
- const char *architecture = ElfArchitecture<ElfClass>(elf_header);
+ const char* architecture = ElfArchitecture<ElfClass>(elf_header);
if (!architecture) {
fprintf(stderr, "%s: unrecognized ELF machine architecture: %d\n",
obj_filename.c_str(), elf_header->e_machine);
@@ -1074,12 +1074,12 @@
return false;
}
-bool WriteSymbolFile(const string &load_path,
- const string &obj_file,
- const string &obj_os,
+bool WriteSymbolFile(const string& load_path,
+ const string& obj_file,
+ const string& obj_os,
const std::vector<string>& debug_dirs,
const DumpOptions& options,
- std::ostream &sym_stream) {
+ std::ostream& sym_stream) {
Module* module;
if (!ReadSymbolData(load_path, obj_file, obj_os, debug_dirs, options,
&module))
@@ -1096,7 +1096,7 @@
bool WriteSymbolFileHeader(const string& load_path,
const string& obj_file,
const string& obj_os,
- std::ostream &sym_stream) {
+ std::ostream& sym_stream) {
MmapWrapper map_wrapper;
void* elf_header = NULL;
if (!LoadELF(load_path, &map_wrapper, &elf_header)) {
diff --git a/src/common/linux/dump_symbols.h b/src/common/linux/dump_symbols.h
index eaddd8b..b033ce0 100644
--- a/src/common/linux/dump_symbols.h
+++ b/src/common/linux/dump_symbols.h
@@ -62,12 +62,12 @@
// If OBJ_FILE has been stripped but contains a .gnu_debuglink section,
// then look for the debug file in DEBUG_DIRS.
// SYMBOL_DATA allows limiting the type of symbol data written.
-bool WriteSymbolFile(const string &load_path,
- const string &obj_file,
- const string &obj_os,
+bool WriteSymbolFile(const string& load_path,
+ const string& obj_file,
+ const string& obj_os,
const std::vector<string>& debug_dirs,
const DumpOptions& options,
- std::ostream &sym_stream);
+ std::ostream& sym_stream);
// Read the selected object file's debugging information, and write out the
// header only to |stream|. Return true on success; if an error occurs, report
@@ -76,7 +76,7 @@
bool WriteSymbolFileHeader(const string& load_path,
const string& obj_file,
const string& obj_os,
- std::ostream &sym_stream);
+ std::ostream& sym_stream);
// As above, but simply return the debugging information in MODULE
// instead of writing it to a stream. The caller owns the resulting
diff --git a/src/common/linux/elf_symbols_to_module.cc b/src/common/linux/elf_symbols_to_module.cc
index 562875e..81e985a 100644
--- a/src/common/linux/elf_symbols_to_module.cc
+++ b/src/common/linux/elf_symbols_to_module.cc
@@ -69,7 +69,7 @@
// otherwise. Assume each symbol has a 'value' field whose size is
// VALUE_SIZE.
//
- ELFSymbolIterator(const ByteBuffer *buffer, bool big_endian,
+ ELFSymbolIterator(const ByteBuffer* buffer, bool big_endian,
size_t value_size)
: value_size_(value_size), cursor_(buffer, big_endian) {
// Actually, weird sizes could be handled just fine, but they're
@@ -81,13 +81,13 @@
// Move to the next symbol. This function's behavior is undefined if
// at_end() is true when it is called.
- ELFSymbolIterator &operator++() { Fetch(); symbol_.index++; return *this; }
+ ELFSymbolIterator& operator++() { Fetch(); symbol_.index++; return *this; }
// Dereferencing this iterator produces a reference to an Symbol structure
// that holds the current symbol's values. The symbol is owned by this
// SymbolIterator, and will be invalidated at the next call to operator++.
- const Symbol &operator*() const { return symbol_; }
- const Symbol *operator->() const { return &symbol_; }
+ const Symbol& operator*() const { return symbol_; }
+ const Symbol* operator->() const { return &symbol_; }
private:
// Read the symbol at cursor_, and set symbol_ appropriately.
@@ -126,21 +126,21 @@
Symbol symbol_;
};
-const char *SymbolString(ptrdiff_t offset, ByteBuffer& strings) {
+const char* SymbolString(ptrdiff_t offset, ByteBuffer& strings) {
if (offset < 0 || (size_t) offset >= strings.Size()) {
// Return the null string.
offset = 0;
}
- return reinterpret_cast<const char *>(strings.start + offset);
+ return reinterpret_cast<const char*>(strings.start + offset);
}
-bool ELFSymbolsToModule(const uint8_t *symtab_section,
+bool ELFSymbolsToModule(const uint8_t* symtab_section,
size_t symtab_size,
- const uint8_t *string_section,
+ const uint8_t* string_section,
size_t string_size,
const bool big_endian,
size_t value_size,
- Module *module) {
+ Module* module) {
ByteBuffer symbols(symtab_section, symtab_size);
// Ensure that the string section is null-terminated.
if (string_section[string_size - 1] != '\0') {
@@ -156,7 +156,7 @@
while(!iterator->at_end) {
if (ELF32_ST_TYPE(iterator->info) == STT_FUNC &&
iterator->shndx != SHN_UNDEF) {
- Module::Extern *ext = new Module::Extern(iterator->value);
+ Module::Extern* ext = new Module::Extern(iterator->value);
ext->name = SymbolString(iterator->name_offset, strings);
#if !defined(__ANDROID__) // Android NDK doesn't provide abi::__cxa_demangle.
int status = 0;
diff --git a/src/common/linux/elf_symbols_to_module.h b/src/common/linux/elf_symbols_to_module.h
index 2e7c097..861f725 100644
--- a/src/common/linux/elf_symbols_to_module.h
+++ b/src/common/linux/elf_symbols_to_module.h
@@ -44,13 +44,13 @@
class Module;
-bool ELFSymbolsToModule(const uint8_t *symtab_section,
+bool ELFSymbolsToModule(const uint8_t* symtab_section,
size_t symtab_size,
- const uint8_t *string_section,
+ const uint8_t* string_section,
size_t string_size,
const bool big_endian,
size_t value_size,
- Module *module);
+ Module* module);
} // namespace google_breakpad
diff --git a/src/common/linux/elf_symbols_to_module_unittest.cc b/src/common/linux/elf_symbols_to_module_unittest.cc
index 8984449..3f66589 100644
--- a/src/common/linux/elf_symbols_to_module_unittest.cc
+++ b/src/common/linux/elf_symbols_to_module_unittest.cc
@@ -86,7 +86,7 @@
// 4 or 8 (bytes)
size_t value_size;
- vector<Module::Extern *> externs;
+ vector<Module::Extern*> externs;
};
class ELFSymbolsToModuleTest32 : public ELFSymbolsToModuleTestFixture,
diff --git a/src/common/linux/elfutils.cc b/src/common/linux/elfutils.cc
index 9532d5a..ce9e9c1 100644
--- a/src/common/linux/elfutils.cc
+++ b/src/common/linux/elfutils.cc
@@ -40,11 +40,11 @@
namespace {
template<typename ElfClass>
-void FindElfClassSection(const char *elf_base,
- const char *section_name,
+void FindElfClassSection(const char* elf_base,
+ const char* section_name,
typename ElfClass::Word section_type,
- const void **section_start,
- size_t *section_size) {
+ const void** section_start,
+ size_t* section_size) {
typedef typename ElfClass::Ehdr Ehdr;
typedef typename ElfClass::Shdr Shdr;
@@ -62,7 +62,7 @@
const Shdr* section_names = sections + elf_header->e_shstrndx;
const char* names =
GetOffset<ElfClass, char>(elf_header, section_names->sh_offset);
- const char *names_end = names + section_names->sh_size;
+ const char* names_end = names + section_names->sh_size;
const Shdr* section =
FindElfSectionByName<ElfClass>(section_name, section_type,
@@ -76,9 +76,9 @@
}
template<typename ElfClass>
-void FindElfClassSegment(const char *elf_base,
+void FindElfClassSegment(const char* elf_base,
typename ElfClass::Word segment_type,
- wasteful_vector<ElfSegment> *segments) {
+ wasteful_vector<ElfSegment>* segments) {
typedef typename ElfClass::Ehdr Ehdr;
typedef typename ElfClass::Phdr Phdr;
@@ -117,11 +117,11 @@
return elf_header->e_ident[EI_CLASS];
}
-bool FindElfSection(const void *elf_mapped_base,
- const char *section_name,
+bool FindElfSection(const void* elf_mapped_base,
+ const char* section_name,
uint32_t section_type,
- const void **section_start,
- size_t *section_size) {
+ const void** section_start,
+ size_t* section_size) {
assert(elf_mapped_base);
assert(section_start);
assert(section_size);
diff --git a/src/common/linux/elfutils.h b/src/common/linux/elfutils.h
index aefb6cf..ec5872a 100644
--- a/src/common/linux/elfutils.h
+++ b/src/common/linux/elfutils.h
@@ -86,11 +86,11 @@
// in the ELF binary data at |elf_mapped_base|. On success, returns true
// and sets |*section_start| to point to the start of the section data,
// and |*section_size| to the size of the section's data.
-bool FindElfSection(const void *elf_mapped_base,
- const char *section_name,
+bool FindElfSection(const void* elf_mapped_base,
+ const char* section_name,
uint32_t section_type,
- const void **section_start,
- size_t *section_size);
+ const void** section_start,
+ size_t* section_size);
// Internal helper method, exposed for convenience for callers
// that already have more info.
diff --git a/src/common/linux/file_id.cc b/src/common/linux/file_id.cc
index 67921c4..9944af7 100644
--- a/src/common/linux/file_id.cc
+++ b/src/common/linux/file_id.cc
@@ -61,7 +61,7 @@
// These functions are also used inside the crashed process, so be safe
// and use the syscall/libc wrappers instead of direct syscalls or libc.
-static bool ElfClassBuildIDNoteIdentifier(const void *section, size_t length,
+static bool ElfClassBuildIDNoteIdentifier(const void* section, size_t length,
wasteful_vector<uint8_t>& identifier) {
static_assert(sizeof(ElfClass32::Nhdr) == sizeof(ElfClass64::Nhdr),
"Elf32_Nhdr and Elf64_Nhdr should be the same");
@@ -69,7 +69,7 @@
const void* section_end = reinterpret_cast<const char*>(section) + length;
const Nhdr* note_header = reinterpret_cast<const Nhdr*>(section);
- while (reinterpret_cast<const void *>(note_header) < section_end) {
+ while (reinterpret_cast<const void*>(note_header) < section_end) {
if (note_header->n_type == NT_GNU_BUILD_ID)
break;
note_header = reinterpret_cast<const Nhdr*>(
@@ -77,7 +77,7 @@
NOTE_PADDING(note_header->n_namesz) +
NOTE_PADDING(note_header->n_descsz));
}
- if (reinterpret_cast<const void *>(note_header) >= section_end ||
+ if (reinterpret_cast<const void*>(note_header) >= section_end ||
note_header->n_descsz == 0) {
return false;
}
diff --git a/src/common/linux/file_id_unittest.cc b/src/common/linux/file_id_unittest.cc
index f4f9ac4..477783d 100644
--- a/src/common/linux/file_id_unittest.cc
+++ b/src/common/linux/file_id_unittest.cc
@@ -261,7 +261,7 @@
elf.AddSection(".text", text, SHT_PROGBITS);
Notes notes(kLittleEndian);
notes.AddNote(0, "Linux",
- reinterpret_cast<const uint8_t *>("\0x42\0x02\0\0"), 4);
+ reinterpret_cast<const uint8_t*>("\0x42\0x02\0\0"), 4);
notes.AddNote(NT_GNU_BUILD_ID, "GNU", kExpectedIdentifierBytes,
sizeof(kExpectedIdentifierBytes));
int note_idx = elf.AddSection(".note", notes, SHT_NOTE);
@@ -292,7 +292,7 @@
elf.AddSection(".text", text, SHT_PROGBITS);
Notes notes1(kLittleEndian);
notes1.AddNote(0, "Linux",
- reinterpret_cast<const uint8_t *>("\0x42\0x02\0\0"), 4);
+ reinterpret_cast<const uint8_t*>("\0x42\0x02\0\0"), 4);
Notes notes2(kLittleEndian);
notes2.AddNote(NT_GNU_BUILD_ID, "GNU", kExpectedIdentifierBytes,
sizeof(kExpectedIdentifierBytes));
diff --git a/src/common/linux/guid_creator.cc b/src/common/linux/guid_creator.cc
index 03e3d78..6374063 100644
--- a/src/common/linux/guid_creator.cc
+++ b/src/common/linux/guid_creator.cc
@@ -105,7 +105,7 @@
private:
#ifdef HAVE_ARC4RANDOM
static void CreateGuidFromArc4Random(GUID *guid) {
- char *buf = reinterpret_cast<char *>(guid);
+ char *buf = reinterpret_cast<char*>(guid);
for (size_t i = 0; i < sizeof(GUID); i += sizeof(uint32_t)) {
uint32_t random_data = arc4random();
@@ -129,7 +129,7 @@
#if defined(HAVE_SYS_RANDOM_H) && defined(HAVE_GETRANDOM)
static bool CreateGUIDFromGetrandom(GUID *guid) {
- char *buf = reinterpret_cast<char *>(guid);
+ char *buf = reinterpret_cast<char*>(guid);
int read_bytes = getrandom(buf, sizeof(GUID), GRND_NONBLOCK);
return (read_bytes == static_cast<int>(sizeof(GUID)));
@@ -139,7 +139,7 @@
// Populate the GUID using random bytes read from /dev/urandom, returns false
// if the GUID wasn't fully populated with random data.
static bool CreateGUIDFromDevUrandom(GUID *guid) {
- char *buf = reinterpret_cast<char *>(guid);
+ char *buf = reinterpret_cast<char*>(guid);
int fd = open("/dev/urandom", O_RDONLY | O_CLOEXEC);
if (fd == -1) {
@@ -154,7 +154,7 @@
// Populate the GUID using a stream of random bytes obtained from rand().
static void CreateGUIDFromRand(GUID *guid) {
- char *buf = reinterpret_cast<char *>(guid);
+ char *buf = reinterpret_cast<char*>(guid);
InitOnce();
diff --git a/src/common/linux/http_upload.cc b/src/common/linux/http_upload.cc
index 702526a..ace12b8 100644
--- a/src/common/linux/http_upload.cc
+++ b/src/common/linux/http_upload.cc
@@ -36,14 +36,14 @@
namespace {
// Callback to get the response data from server.
-static size_t WriteCallback(void *ptr, size_t size,
- size_t nmemb, void *userp) {
+static size_t WriteCallback(void* ptr, size_t size,
+ size_t nmemb, void* userp) {
if (!userp)
return 0;
- string *response = reinterpret_cast<string *>(userp);
+ string* response = reinterpret_cast<string*>(userp);
size_t real_size = size * nmemb;
- response->append(reinterpret_cast<char *>(ptr), real_size);
+ response->append(reinterpret_cast<char*>(ptr), real_size);
return real_size;
}
@@ -54,15 +54,15 @@
static const char kUserAgent[] = "Breakpad/1.0 (Linux)";
// static
-bool HTTPUpload::SendRequest(const string &url,
- const map<string, string> ¶meters,
- const map<string, string> &files,
- const string &proxy,
- const string &proxy_user_pwd,
- const string &ca_certificate_file,
- string *response_body,
- long *response_code,
- string *error_description) {
+bool HTTPUpload::SendRequest(const string& url,
+ const map<string, string>& parameters,
+ const map<string, string>& files,
+ const string& proxy,
+ const string& proxy_user_pwd,
+ const string& ca_certificate_file,
+ string* response_body,
+ long* response_code,
+ string* error_description) {
if (response_code != NULL)
*response_code = 0;
@@ -101,7 +101,7 @@
CURL* (*curl_easy_init)(void);
*(void**) (&curl_easy_init) = dlsym(curl_lib, "curl_easy_init");
- CURL *curl = (*curl_easy_init)();
+ CURL* curl = (*curl_easy_init)();
if (error_description != NULL)
*error_description = "No Error";
@@ -111,7 +111,7 @@
}
CURLcode err_code = CURLE_OK;
- CURLcode (*curl_easy_setopt)(CURL *, CURLoption, ...);
+ CURLcode (*curl_easy_setopt)(CURL*, CURLoption, ...);
*(void**) (&curl_easy_setopt) = dlsym(curl_lib, "curl_easy_setopt");
(*curl_easy_setopt)(curl, CURLOPT_URL, url.c_str());
(*curl_easy_setopt)(curl, CURLOPT_USERAGENT, kUserAgent);
@@ -128,10 +128,10 @@
if (!ca_certificate_file.empty())
(*curl_easy_setopt)(curl, CURLOPT_CAINFO, ca_certificate_file.c_str());
- struct curl_httppost *formpost = NULL;
- struct curl_httppost *lastptr = NULL;
+ struct curl_httppost* formpost = NULL;
+ struct curl_httppost* lastptr = NULL;
// Add form data.
- CURLFORMcode (*curl_formadd)(struct curl_httppost **, struct curl_httppost **, ...);
+ CURLFORMcode (*curl_formadd)(struct curl_httppost**, struct curl_httppost**, ...);
*(void**) (&curl_formadd) = dlsym(curl_lib, "curl_formadd");
map<string, string>::const_iterator iter = parameters.begin();
for (; iter != parameters.end(); ++iter)
@@ -151,9 +151,9 @@
(*curl_easy_setopt)(curl, CURLOPT_HTTPPOST, formpost);
// Disable 100-continue header.
- struct curl_slist *headerlist = NULL;
+ struct curl_slist* headerlist = NULL;
char buf[] = "Expect:";
- struct curl_slist* (*curl_slist_append)(struct curl_slist *, const char *);
+ struct curl_slist* (*curl_slist_append)(struct curl_slist*, const char*);
*(void**) (&curl_slist_append) = dlsym(curl_lib, "curl_slist_append");
headerlist = (*curl_slist_append)(headerlist, buf);
(*curl_easy_setopt)(curl, CURLOPT_HTTPHEADER, headerlist);
@@ -161,17 +161,17 @@
if (response_body != NULL) {
(*curl_easy_setopt)(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
(*curl_easy_setopt)(curl, CURLOPT_WRITEDATA,
- reinterpret_cast<void *>(response_body));
+ reinterpret_cast<void*>(response_body));
}
// Fail if 400+ is returned from the web server.
(*curl_easy_setopt)(curl, CURLOPT_FAILONERROR, 1);
- CURLcode (*curl_easy_perform)(CURL *);
+ CURLcode (*curl_easy_perform)(CURL*);
*(void**) (&curl_easy_perform) = dlsym(curl_lib, "curl_easy_perform");
err_code = (*curl_easy_perform)(curl);
if (response_code != NULL) {
- CURLcode (*curl_easy_getinfo)(CURL *, CURLINFO, ...);
+ CURLcode (*curl_easy_getinfo)(CURL*, CURLINFO, ...);
*(void**) (&curl_easy_getinfo) = dlsym(curl_lib, "curl_easy_getinfo");
(*curl_easy_getinfo)(curl, CURLINFO_RESPONSE_CODE, response_code);
}
@@ -186,16 +186,16 @@
if (error_description != NULL)
*error_description = (*curl_easy_strerror)(err_code);
- void (*curl_easy_cleanup)(CURL *);
+ void (*curl_easy_cleanup)(CURL*);
*(void**) (&curl_easy_cleanup) = dlsym(curl_lib, "curl_easy_cleanup");
(*curl_easy_cleanup)(curl);
if (formpost != NULL) {
- void (*curl_formfree)(struct curl_httppost *);
+ void (*curl_formfree)(struct curl_httppost*);
*(void**) (&curl_formfree) = dlsym(curl_lib, "curl_formfree");
(*curl_formfree)(formpost);
}
if (headerlist != NULL) {
- void (*curl_slist_free_all)(struct curl_slist *);
+ void (*curl_slist_free_all)(struct curl_slist*);
*(void**) (&curl_slist_free_all) = dlsym(curl_lib, "curl_slist_free_all");
(*curl_slist_free_all)(headerlist);
}
@@ -211,10 +211,10 @@
}
// static
-bool HTTPUpload::CheckParameters(const map<string, string> ¶meters) {
+bool HTTPUpload::CheckParameters(const map<string, string>& parameters) {
for (map<string, string>::const_iterator pos = parameters.begin();
pos != parameters.end(); ++pos) {
- const string &str = pos->first;
+ const string& str = pos->first;
if (str.size() == 0)
return false; // disallow empty parameter names
for (unsigned int i = 0; i < str.size(); ++i) {
diff --git a/src/common/linux/http_upload.h b/src/common/linux/http_upload.h
index bc1d5d5..13f3d56 100644
--- a/src/common/linux/http_upload.h
+++ b/src/common/linux/http_upload.h
@@ -58,21 +58,21 @@
// received (or 0 if the request failed before getting an HTTP response).
// If the send fails, a description of the error will be
// returned in error_description.
- static bool SendRequest(const string &url,
- const map<string, string> ¶meters,
- const map<string, string> &files,
- const string &proxy,
- const string &proxy_user_pwd,
- const string &ca_certificate_file,
- string *response_body,
- long *response_code,
- string *error_description);
+ static bool SendRequest(const string& url,
+ const map<string, string>& parameters,
+ const map<string, string>& files,
+ const string& proxy,
+ const string& proxy_user_pwd,
+ const string& ca_certificate_file,
+ string* response_body,
+ long* response_code,
+ string* error_description);
private:
// Checks that the given list of parameters has only printable
// ASCII characters in the parameter name, and does not contain
// any quote (") characters. Returns true if so.
- static bool CheckParameters(const map<string, string> ¶meters);
+ static bool CheckParameters(const map<string, string>& parameters);
// Checks the curl_lib parameter points to a valid curl lib.
static bool CheckCurlLib(void* curl_lib);
@@ -80,8 +80,8 @@
// No instances of this class should be created.
// Disallow all constructors, destructors, and operator=.
HTTPUpload();
- explicit HTTPUpload(const HTTPUpload &);
- void operator=(const HTTPUpload &);
+ explicit HTTPUpload(const HTTPUpload&);
+ void operator=(const HTTPUpload&);
~HTTPUpload();
};
diff --git a/src/common/linux/libcurl_wrapper.cc b/src/common/linux/libcurl_wrapper.cc
index e96c203..fdb200f 100644
--- a/src/common/linux/libcurl_wrapper.cc
+++ b/src/common/linux/libcurl_wrapper.cc
@@ -88,14 +88,14 @@
}
// Callback to get the response data from server.
-static size_t WriteCallback(void *ptr, size_t size,
- size_t nmemb, void *userp) {
+static size_t WriteCallback(void* ptr, size_t size,
+ size_t nmemb, void* userp) {
if (!userp)
return 0;
- string *response = reinterpret_cast<string *>(userp);
+ string* response = reinterpret_cast<string*>(userp);
size_t real_size = size * nmemb;
- response->append(reinterpret_cast<char *>(ptr), real_size);
+ response->append(reinterpret_cast<char*>(ptr), real_size);
return real_size;
}
@@ -250,7 +250,7 @@
SET_AND_CHECK_FUNCTION_POINTER(easy_getinfo_,
"curl_easy_getinfo",
- CURLcode(*)(CURL *, CURLINFO info, ...));
+ CURLcode(*)(CURL*, CURLINFO info, ...));
SET_AND_CHECK_FUNCTION_POINTER(easy_reset_,
"curl_easy_reset",
diff --git a/src/common/linux/libcurl_wrapper.h b/src/common/linux/libcurl_wrapper.h
index 77aa6cb..823f83c 100644
--- a/src/common/linux/libcurl_wrapper.h
+++ b/src/common/linux/libcurl_wrapper.h
@@ -91,27 +91,27 @@
// dealing
// with CURL.
- CURL *curl_; // Pointer for handle for CURL calls.
+ CURL* curl_; // Pointer for handle for CURL calls.
CURL* (*easy_init_)(void);
// Stateful pointers for calling into curl_formadd()
- struct curl_httppost *formpost_;
- struct curl_httppost *lastptr_;
- struct curl_slist *headerlist_;
+ struct curl_httppost* formpost_;
+ struct curl_httppost* lastptr_;
+ struct curl_slist* headerlist_;
// Function pointers into CURL library
- CURLcode (*easy_setopt_)(CURL *, CURLoption, ...);
- CURLFORMcode (*formadd_)(struct curl_httppost **,
- struct curl_httppost **, ...);
- struct curl_slist* (*slist_append_)(struct curl_slist *, const char *);
- void (*slist_free_all_)(struct curl_slist *);
- CURLcode (*easy_perform_)(CURL *);
+ CURLcode (*easy_setopt_)(CURL*, CURLoption, ...);
+ CURLFORMcode (*formadd_)(struct curl_httppost**,
+ struct curl_httppost**, ...);
+ struct curl_slist* (*slist_append_)(struct curl_slist*, const char*);
+ void (*slist_free_all_)(struct curl_slist*);
+ CURLcode (*easy_perform_)(CURL*);
const char* (*easy_strerror_)(CURLcode);
- void (*easy_cleanup_)(CURL *);
- CURLcode (*easy_getinfo_)(CURL *, CURLINFO info, ...);
+ void (*easy_cleanup_)(CURL*);
+ CURLcode (*easy_getinfo_)(CURL*, CURLINFO info, ...);
void (*easy_reset_)(CURL*);
- void (*formfree_)(struct curl_httppost *);
+ void (*formfree_)(struct curl_httppost*);
};
}
diff --git a/src/common/linux/linux_libc_support.cc b/src/common/linux/linux_libc_support.cc
index 08b0325..dd29296 100644
--- a/src/common/linux/linux_libc_support.cc
+++ b/src/common/linux/linux_libc_support.cc
@@ -190,7 +190,7 @@
}
void my_memset(void* ip, char c, size_t len) {
- char* p = (char *) ip;
+ char* p = (char*) ip;
while (len--)
*p++ = c;
}
diff --git a/src/common/linux/symbol_upload.cc b/src/common/linux/symbol_upload.cc
index 87741a0..1d5ff71 100644
--- a/src/common/linux/symbol_upload.cc
+++ b/src/common/linux/symbol_upload.cc
@@ -46,8 +46,8 @@
namespace google_breakpad {
namespace sym_upload {
-void TokenizeByChar(const string &source_string, int c,
- std::vector<string> *results) {
+void TokenizeByChar(const string& source_string, int c,
+ std::vector<string>* results) {
assert(results);
string::size_type cur_pos = 0, next_pos = 0;
while ((next_pos = source_string.find(c, cur_pos)) != string::npos) {
@@ -62,8 +62,8 @@
//=============================================================================
// Parse out the module line which have 5 parts.
// MODULE <os> <cpu> <uuid> <module-name>
-bool ModuleDataForSymbolFile(const string &file,
- std::vector<string> *module_parts) {
+bool ModuleDataForSymbolFile(const string& file,
+ std::vector<string>* module_parts) {
assert(module_parts);
const size_t kModulePartNumber = 5;
FILE* fp = fopen(file.c_str(), "r");
@@ -90,7 +90,7 @@
}
//=============================================================================
-string CompactIdentifier(const string &uuid) {
+string CompactIdentifier(const string& uuid) {
std::vector<string> components;
TokenizeByChar(uuid, '-', &components);
string result;
diff --git a/src/common/linux/synth_elf.cc b/src/common/linux/synth_elf.cc
index 98e81da..2ba25e6 100644
--- a/src/common/linux/synth_elf.cc
+++ b/src/common/linux/synth_elf.cc
@@ -118,7 +118,7 @@
return index;
}
-void ELF::AppendSection(ElfSection §ion) {
+void ELF::AppendSection(ElfSection& section) {
// NULL and NOBITS sections have no content, so they
// don't need to be written to the file.
if (section.type_ == SHT_NULL) {
@@ -242,7 +242,7 @@
D64(size);
}
-void Notes::AddNote(int type, const string &name, const uint8_t* desc_bytes,
+void Notes::AddNote(int type, const string& name, const uint8_t* desc_bytes,
size_t desc_size) {
// Elf32_Nhdr and Elf64_Nhdr are exactly the same.
Elf32_Nhdr note_header;
diff --git a/src/common/linux/synth_elf.h b/src/common/linux/synth_elf.h
index 1d2a20c..90fa28c 100644
--- a/src/common/linux/synth_elf.h
+++ b/src/common/linux/synth_elf.h
@@ -154,7 +154,7 @@
vector<ElfSection> sections_;
- void AppendSection(ElfSection §ion);
+ void AppendSection(ElfSection& section);
};
// A class to build .symtab or .dynsym sections.
@@ -187,7 +187,7 @@
}
// Add a note.
- void AddNote(int type, const string &name, const uint8_t* desc_bytes,
+ void AddNote(int type, const string& name, const uint8_t* desc_bytes,
size_t desc_size);
};
diff --git a/src/common/linux/synth_elf_unittest.cc b/src/common/linux/synth_elf_unittest.cc
index cd74c28..fb3601e 100644
--- a/src/common/linux/synth_elf_unittest.cc
+++ b/src/common/linux/synth_elf_unittest.cc
@@ -381,9 +381,9 @@
TEST_F(ElfNotesTest, Notes) {
Notes notes(kLittleEndian);
- notes.AddNote(1, "Linux", reinterpret_cast<const uint8_t *>("\x42\x02\0\0"),
+ notes.AddNote(1, "Linux", reinterpret_cast<const uint8_t*>("\x42\x02\0\0"),
4);
- notes.AddNote(2, "a", reinterpret_cast<const uint8_t *>("foobar"),
+ notes.AddNote(2, "a", reinterpret_cast<const uint8_t*>("foobar"),
sizeof("foobar") - 1);
const uint8_t kExpectedNotesContents[] = {
diff --git a/src/common/linux/tests/crash_generator.cc b/src/common/linux/tests/crash_generator.cc
index 6896a68..a70df28 100644
--- a/src/common/linux/tests/crash_generator.cc
+++ b/src/common/linux/tests/crash_generator.cc
@@ -79,7 +79,7 @@
// Core file size limit set to 1 MB, which is big enough for test purposes.
const rlim_t kCoreSizeLimit = 1024 * 1024;
-void *thread_function(void *data) {
+void* thread_function(void* data) {
ThreadData* thread_data = reinterpret_cast<ThreadData*>(data);
volatile pid_t thread_id = gettid();
*(thread_data->thread_id_ptr) = thread_id;
diff --git a/src/common/mac/MachIPC.h b/src/common/mac/MachIPC.h
index 71419be..a3fae5a 100644
--- a/src/common/mac/MachIPC.h
+++ b/src/common/mac/MachIPC.h
@@ -73,7 +73,7 @@
// mach_port_t task = message.GetTranslatedPort(0);
// mach_port_t thread = message.GetTranslatedPort(1);
//
-// char *messageString = message.GetData();
+// char* messageString = message.GetData();
//
// printf("message string = %s\n", messageString);
// }
@@ -164,7 +164,7 @@
public:
// The receiver of the message can retrieve the raw data this way
- uint8_t *GetData() {
+ uint8_t* GetData() {
return GetDataLength() > 0 ? GetDataPacket()->data : NULL;
}
@@ -181,10 +181,10 @@
// Adds a descriptor (typically a mach port) to be translated
// returns true if successful, otherwise not enough space
- bool AddDescriptor(const MachMsgPortDescriptor &desc);
+ bool AddDescriptor(const MachMsgPortDescriptor& desc);
int GetDescriptorCount() const { return body.msgh_descriptor_count; }
- MachMsgPortDescriptor *GetDescriptor(int n);
+ MachMsgPortDescriptor* GetDescriptor(int n);
// Convenience method which gets the mach port described by the descriptor
mach_port_t GetTranslatedPort(int n);
@@ -193,7 +193,7 @@
bool IsSimpleMessage() const { return GetDescriptorCount() == 0; }
// Sets raw data for the message (returns false if not enough space)
- bool SetData(void *data, int32_t data_length);
+ bool SetData(void* data, int32_t data_length);
protected:
// Consider this an abstract base class - must create an actual instance
@@ -216,7 +216,7 @@
MessageDataPacket* GetDataPacket();
void SetDescriptorCount(int n);
- void SetDescriptor(int n, const MachMsgPortDescriptor &desc);
+ void SetDescriptor(int n, const MachMsgPortDescriptor& desc);
// Returns total message size setting msgh_size in the header to this value
mach_msg_size_t CalculateSize();
@@ -250,7 +250,7 @@
class ReceivePort {
public:
// Creates a new mach port for receiving messages and registers a name for it
- explicit ReceivePort(const char *receive_port_name);
+ explicit ReceivePort(const char* receive_port_name);
// Given an already existing mach port, use it. We take ownership of the
// port and deallocate it in our destructor.
@@ -262,7 +262,7 @@
~ReceivePort();
// Waits on the mach port until message received or timeout
- kern_return_t WaitForMessage(MachReceiveMessage *out_message,
+ kern_return_t WaitForMessage(MachReceiveMessage* out_message,
mach_msg_timeout_t timeout);
// The underlying mach port that we wrap
@@ -280,13 +280,13 @@
class MachPortSender {
public:
// get a port with send rights corresponding to a named registered service
- explicit MachPortSender(const char *receive_port_name);
+ explicit MachPortSender(const char* receive_port_name);
// Given an already existing mach port, use it.
explicit MachPortSender(mach_port_t send_port);
- kern_return_t SendMessage(MachSendMessage &message,
+ kern_return_t SendMessage(MachSendMessage& message,
mach_msg_timeout_t timeout);
private:
diff --git a/src/common/mac/MachIPC.mm b/src/common/mac/MachIPC.mm
index dc9773f..b41a825 100644
--- a/src/common/mac/MachIPC.mm
+++ b/src/common/mac/MachIPC.mm
@@ -52,7 +52,7 @@
//==============================================================================
// returns true if successful
-bool MachMessage::SetData(void *data,
+bool MachMessage::SetData(void* data,
int32_t data_length) {
// first check to make sure we have enough space
size_t size = CalculateSize();
@@ -90,9 +90,9 @@
}
//==============================================================================
-MachMessage::MessageDataPacket *MachMessage::GetDataPacket() {
+MachMessage::MessageDataPacket* MachMessage::GetDataPacket() {
size_t desc_size = sizeof(MachMsgPortDescriptor)*GetDescriptorCount();
- MessageDataPacket *packet =
+ MessageDataPacket* packet =
reinterpret_cast<MessageDataPacket*>(padding + desc_size);
return packet;
@@ -100,15 +100,15 @@
//==============================================================================
void MachMessage::SetDescriptor(int n,
- const MachMsgPortDescriptor &desc) {
- MachMsgPortDescriptor *desc_array =
+ const MachMsgPortDescriptor& desc) {
+ MachMsgPortDescriptor* desc_array =
reinterpret_cast<MachMsgPortDescriptor*>(padding);
desc_array[n] = desc;
}
//==============================================================================
// returns true if successful otherwise there was not enough space
-bool MachMessage::AddDescriptor(const MachMsgPortDescriptor &desc) {
+bool MachMessage::AddDescriptor(const MachMsgPortDescriptor& desc) {
// first check to make sure we have enough space
int size = CalculateSize();
size_t new_size = size + sizeof(MachMsgPortDescriptor);
@@ -119,7 +119,7 @@
// unfortunately, we need to move the data to allow space for the
// new descriptor
- u_int8_t *p = reinterpret_cast<u_int8_t*>(GetDataPacket());
+ u_int8_t* p = reinterpret_cast<u_int8_t*>(GetDataPacket());
bcopy(p, p+sizeof(MachMsgPortDescriptor), GetDataLength()+2*sizeof(int32_t));
SetDescriptor(GetDescriptorCount(), desc);
@@ -142,9 +142,9 @@
}
//==============================================================================
-MachMsgPortDescriptor *MachMessage::GetDescriptor(int n) {
+MachMsgPortDescriptor* MachMessage::GetDescriptor(int n) {
if (n < GetDescriptorCount()) {
- MachMsgPortDescriptor *desc =
+ MachMsgPortDescriptor* desc =
reinterpret_cast<MachMsgPortDescriptor*>(padding);
return desc + n;
}
@@ -164,7 +164,7 @@
//==============================================================================
// create a new mach port for receiving messages and register a name for it
-ReceivePort::ReceivePort(const char *receive_port_name) {
+ReceivePort::ReceivePort(const char* receive_port_name) {
mach_port_t current_task = mach_task_self();
init_result_ = mach_port_allocate(current_task,
@@ -227,7 +227,7 @@
}
//==============================================================================
-kern_return_t ReceivePort::WaitForMessage(MachReceiveMessage *out_message,
+kern_return_t ReceivePort::WaitForMessage(MachReceiveMessage* out_message,
mach_msg_timeout_t timeout) {
if (!out_message) {
return KERN_INVALID_ARGUMENT;
@@ -261,7 +261,7 @@
//==============================================================================
// get a port with send rights corresponding to a named registered service
-MachPortSender::MachPortSender(const char *receive_port_name) {
+MachPortSender::MachPortSender(const char* receive_port_name) {
mach_port_t task_bootstrap_port = 0;
init_result_ = task_get_bootstrap_port(mach_task_self(),
&task_bootstrap_port);
@@ -281,7 +281,7 @@
}
//==============================================================================
-kern_return_t MachPortSender::SendMessage(MachSendMessage &message,
+kern_return_t MachPortSender::SendMessage(MachSendMessage& message,
mach_msg_timeout_t timeout) {
if (message.head.msgh_size == 0) {
return KERN_INVALID_VALUE; // just for safety -- never should occur
diff --git a/src/common/mac/dump_syms.cc b/src/common/mac/dump_syms.cc
index 2734ff6..24bcd65 100644
--- a/src/common/mac/dump_syms.cc
+++ b/src/common/mac/dump_syms.cc
@@ -120,7 +120,7 @@
namespace google_breakpad {
-bool DumpSymbols::Read(const string &filename) {
+bool DumpSymbols::Read(const string& filename) {
struct stat st;
if (stat(filename.c_str(), &st) == -1) {
fprintf(stderr, "Could not access object file %s: %s\n",
@@ -195,7 +195,7 @@
// Get our own copy of fat_reader's object file list.
size_t object_files_count;
- const SuperFatArch *object_files =
+ const SuperFatArch* object_files =
fat_reader.object_files(&object_files_count);
if (object_files_count == 0) {
fprintf(stderr, "Fat binary file contains *no* architectures: %s\n",
@@ -212,7 +212,7 @@
bool DumpSymbols::SetArchitecture(cpu_type_t cpu_type,
cpu_subtype_t cpu_subtype) {
// Find the best match for the architecture the user requested.
- const SuperFatArch *best_match = FindBestMatchForArchitecture(
+ const SuperFatArch* best_match = FindBestMatchForArchitecture(
cpu_type, cpu_subtype);
if (!best_match) return false;
@@ -221,9 +221,9 @@
return true;
}
-bool DumpSymbols::SetArchitecture(const std::string &arch_name) {
+bool DumpSymbols::SetArchitecture(const std::string& arch_name) {
bool arch_set = false;
- const NXArchInfo *arch_info =
+ const NXArchInfo* arch_info =
google_breakpad::BreakpadGetArchInfoFromName(arch_name.c_str());
if (arch_info) {
arch_set = SetArchitecture(arch_info->cputype, arch_info->cpusubtype);
@@ -251,7 +251,7 @@
// If all the object files can be converted to struct fat_arch, use
// NXFindBestFatArch.
if (can_convert_to_fat_arch) {
- const struct fat_arch *best_match
+ const struct fat_arch* best_match
= NXFindBestFatArch(cpu_type, cpu_subtype, &fat_arch_vector[0],
static_cast<uint32_t>(fat_arch_vector.size()));
@@ -311,7 +311,7 @@
class DumpSymbols::DumperRangesHandler:
public DwarfCUToModule::RangesHandler {
public:
- DumperRangesHandler(const uint8_t *buffer, uint64_t size,
+ DumperRangesHandler(const uint8_t* buffer, uint64_t size,
dwarf2reader::ByteReader* reader)
: buffer_(buffer), size_(size), reader_(reader) { }
@@ -325,7 +325,7 @@
}
private:
- const uint8_t *buffer_;
+ const uint8_t* buffer_;
uint64_t size_;
dwarf2reader::ByteReader* reader_;
};
@@ -337,7 +337,7 @@
public DwarfCUToModule::LineToModuleHandler {
public:
// Create a line-to-module converter using BYTE_READER.
- DumperLineToModule(dwarf2reader::ByteReader *byte_reader)
+ DumperLineToModule(dwarf2reader::ByteReader* byte_reader)
: byte_reader_(byte_reader) { }
void StartCompilationUnit(const string& compilation_dir) {
@@ -357,7 +357,7 @@
}
private:
string compilation_dir_;
- dwarf2reader::ByteReader *byte_reader_; // WEAK
+ dwarf2reader::ByteReader* byte_reader_; // WEAK
};
bool DumpSymbols::CreateEmptyModule(scoped_ptr<Module>& module) {
@@ -369,7 +369,7 @@
selected_object_file_ = &object_files_[0];
else {
// Look for an object file whose architecture matches our own.
- const NXArchInfo *local_arch = NXGetLocalArchInfo();
+ const NXArchInfo* local_arch = NXGetLocalArchInfo();
if (!SetArchitecture(local_arch->cputype, local_arch->cpusubtype)) {
fprintf(stderr, "%s: object file contains more than one"
" architecture, none of which match the current"
@@ -385,11 +385,11 @@
// Find the name of the selected file's architecture, to appear in
// the MODULE record and in error messages.
- const NXArchInfo *selected_arch_info =
+ const NXArchInfo* selected_arch_info =
google_breakpad::BreakpadGetArchInfoFromCpuType(
selected_object_file_->cputype, selected_object_file_->cpusubtype);
- const char *selected_arch_name = selected_arch_info->name;
+ const char* selected_arch_name = selected_arch_info->name;
if (strcmp(selected_arch_name, "i386") == 0)
selected_arch_name = "x86";
@@ -418,9 +418,9 @@
return true;
}
-void DumpSymbols::ReadDwarf(google_breakpad::Module *module,
- const mach_o::Reader &macho_reader,
- const mach_o::SectionMap &dwarf_sections,
+void DumpSymbols::ReadDwarf(google_breakpad::Module* module,
+ const mach_o::Reader& macho_reader,
+ const mach_o::SectionMap& dwarf_sections,
bool handle_inter_cu_refs) const {
// Build a byte reader of the appropriate endianness.
ByteReader byte_reader(macho_reader.big_endian()
@@ -461,7 +461,7 @@
dwarf2reader::SectionMap::const_iterator ranges_entry =
file_context.section_map().find("__debug_ranges");
if (ranges_entry != file_context.section_map().end()) {
- const std::pair<const uint8_t *, uint64_t>& ranges_section =
+ const std::pair<const uint8_t*, uint64_t>& ranges_section =
ranges_entry->second;
ranges_handler.reset(
new DumperRangesHandler(ranges_section.first, ranges_section.second,
@@ -490,9 +490,9 @@
}
}
-bool DumpSymbols::ReadCFI(google_breakpad::Module *module,
- const mach_o::Reader &macho_reader,
- const mach_o::Section §ion,
+bool DumpSymbols::ReadCFI(google_breakpad::Module* module,
+ const mach_o::Reader& macho_reader,
+ const mach_o::Section& section,
bool eh_frame) const {
// Find the appropriate set of register names for this file's
// architecture.
@@ -511,7 +511,7 @@
register_names = DwarfCFIToModule::RegisterNames::ARM64();
break;
default: {
- const NXArchInfo *arch = google_breakpad::BreakpadGetArchInfoFromCpuType(
+ const NXArchInfo* arch = google_breakpad::BreakpadGetArchInfoFromCpuType(
macho_reader.cpu_type(), macho_reader.cpu_subtype());
fprintf(stderr, "%s: cannot convert DWARF call frame information for ",
selected_object_name_.c_str());
@@ -526,7 +526,7 @@
}
// Find the call frame information and its size.
- const uint8_t *cfi = section.contents.start;
+ const uint8_t* cfi = section.contents.start;
size_t cfi_size = section.contents.Size();
// Plug together the parser, handler, and their entourages.
@@ -558,9 +558,9 @@
public:
// Create a load command dumper handling load commands from READER's
// file, and adding data to MODULE.
- LoadCommandDumper(const DumpSymbols &dumper,
- google_breakpad::Module *module,
- const mach_o::Reader &reader,
+ LoadCommandDumper(const DumpSymbols& dumper,
+ google_breakpad::Module* module,
+ const mach_o::Reader& reader,
SymbolData symbol_data,
bool handle_inter_cu_refs)
: dumper_(dumper),
@@ -569,18 +569,18 @@
symbol_data_(symbol_data),
handle_inter_cu_refs_(handle_inter_cu_refs) { }
- bool SegmentCommand(const mach_o::Segment &segment);
- bool SymtabCommand(const ByteBuffer &entries, const ByteBuffer &strings);
+ bool SegmentCommand(const mach_o::Segment& segment);
+ bool SymtabCommand(const ByteBuffer& entries, const ByteBuffer& strings);
private:
- const DumpSymbols &dumper_;
- google_breakpad::Module *module_; // WEAK
- const mach_o::Reader &reader_;
+ const DumpSymbols& dumper_;
+ google_breakpad::Module* module_; // WEAK
+ const mach_o::Reader& reader_;
const SymbolData symbol_data_;
const bool handle_inter_cu_refs_;
};
-bool DumpSymbols::LoadCommandDumper::SegmentCommand(const Segment &segment) {
+bool DumpSymbols::LoadCommandDumper::SegmentCommand(const Segment& segment) {
mach_o::SectionMap section_map;
if (!reader_.MapSegmentSections(segment, §ion_map))
return false;
@@ -615,8 +615,8 @@
return true;
}
-bool DumpSymbols::LoadCommandDumper::SymtabCommand(const ByteBuffer &entries,
- const ByteBuffer &strings) {
+bool DumpSymbols::LoadCommandDumper::SymtabCommand(const ByteBuffer& entries,
+ const ByteBuffer& strings) {
StabsToModule stabs_to_module(module_);
// Mac OS X STABS are never "unitized", and the size of the 'value' field
// matches the address size of the executable.
@@ -658,7 +658,7 @@
return true;
}
-bool DumpSymbols::WriteSymbolFile(std::ostream &stream) {
+bool DumpSymbols::WriteSymbolFile(std::ostream& stream) {
Module* module = NULL;
if (ReadSymbolData(&module) && module) {
@@ -673,7 +673,7 @@
// Read the selected object file's debugging information, and write out the
// header only to |stream|. Return true on success; if an error occurs, report
// it and return false.
-bool DumpSymbols::WriteSymbolFileHeader(std::ostream &stream) {
+bool DumpSymbols::WriteSymbolFileHeader(std::ostream& stream) {
scoped_ptr<Module> module;
if (!CreateEmptyModule(module))
return false;
diff --git a/src/common/mac/dump_syms.h b/src/common/mac/dump_syms.h
index 1e57f86..daebf87 100644
--- a/src/common/mac/dump_syms.h
+++ b/src/common/mac/dump_syms.h
@@ -70,7 +70,7 @@
// the name of a universal binary, a Mach-O file, or a dSYM bundle
// containing either of the above. On success, return true; if there is a
// problem reading |filename|, report it and return false.
- bool Read(const std::string &filename);
+ bool Read(const std::string& filename);
// If this dumper's file includes an object file for |cpu_type| and
// |cpu_subtype|, then select that object file for dumping, and return
@@ -91,7 +91,7 @@
// the dumper will dump those symbols; and if it contains more than one
// object file, then the dumper will dump the object file whose
// architecture matches that of this dumper program.
- bool SetArchitecture(const std::string &arch_name);
+ bool SetArchitecture(const std::string& arch_name);
// Return a pointer to an array of SuperFatArch structures describing the
// object files contained in this dumper's file. Set *|count| to the number
@@ -100,7 +100,7 @@
//
// If there are no available architectures, this function
// may return NULL.
- const SuperFatArch* AvailableArchitectures(size_t *count) {
+ const SuperFatArch* AvailableArchitectures(size_t* count) {
*count = object_files_.size();
if (object_files_.size() > 0)
return &object_files_[0];
@@ -110,12 +110,12 @@
// Read the selected object file's debugging information, and write it out to
// |stream|. Return true on success; if an error occurs, report it and
// return false.
- bool WriteSymbolFile(std::ostream &stream);
+ bool WriteSymbolFile(std::ostream& stream);
// Read the selected object file's debugging information, and write out the
// header only to |stream|. Return true on success; if an error occurs, report
// it and return false.
- bool WriteSymbolFileHeader(std::ostream &stream);
+ bool WriteSymbolFileHeader(std::ostream& stream);
// As above, but simply return the debugging information in module
// instead of writing it to a stream. The caller owns the resulting
@@ -142,9 +142,9 @@
// Read debugging information from |dwarf_sections|, which was taken from
// |macho_reader|, and add it to |module|.
- void ReadDwarf(google_breakpad::Module *module,
- const mach_o::Reader &macho_reader,
- const mach_o::SectionMap &dwarf_sections,
+ void ReadDwarf(google_breakpad::Module* module,
+ const mach_o::Reader& macho_reader,
+ const mach_o::SectionMap& dwarf_sections,
bool handle_inter_cu_refs) const;
// Read DWARF CFI or .eh_frame data from |section|, belonging to
@@ -152,9 +152,9 @@
// then the data is .eh_frame-format data; otherwise, it is standard DWARF
// .debug_frame data. On success, return true; on failure, report
// the problem and return false.
- bool ReadCFI(google_breakpad::Module *module,
- const mach_o::Reader &macho_reader,
- const mach_o::Section §ion,
+ bool ReadCFI(google_breakpad::Module* module,
+ const mach_o::Reader& macho_reader,
+ const mach_o::Section& section,
bool eh_frame) const;
// The selection of what type of symbol data to read/write.
@@ -184,7 +184,7 @@
// The object file in object_files_ selected to dump, or NULL if
// SetArchitecture hasn't been called yet.
- const SuperFatArch *selected_object_file_;
+ const SuperFatArch* selected_object_file_;
// A string that identifies the selected object file, for use in error
// messages. This is usually object_filename_, but if that refers to a
diff --git a/src/common/mac/macho_id.cc b/src/common/mac/macho_id.cc
index c396ad8..3cf1d4b 100644
--- a/src/common/mac/macho_id.cc
+++ b/src/common/mac/macho_id.cc
@@ -53,7 +53,7 @@
using google_breakpad::MD5Update;
using google_breakpad::MD5Final;
-MachoID::MachoID(const char *path)
+MachoID::MachoID(const char* path)
: memory_(0),
memory_size_(0),
crc_(0),
@@ -62,7 +62,7 @@
snprintf(path_, sizeof(path_), "%s", path);
}
-MachoID::MachoID(const char *path, void *memory, size_t size)
+MachoID::MachoID(const char* path, void* memory, size_t size)
: memory_(memory),
memory_size_(size),
crc_(0),
@@ -82,7 +82,7 @@
// MAX_BLOCK is the largest n such that 255n(n+1)/2 + (n+1)(MAX_BLOCK-1) <= 2^32-1
#define MAX_BLOCK 5552
-void MachoID::UpdateCRC(unsigned char *bytes, size_t size) {
+void MachoID::UpdateCRC(unsigned char* bytes, size_t size) {
// Unrolled loops for summing
#define DO1(buf,i) {sum1 += (buf)[i]; sum2 += sum1;}
#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1);
@@ -122,11 +122,11 @@
}
}
-void MachoID::UpdateMD5(unsigned char *bytes, size_t size) {
+void MachoID::UpdateMD5(unsigned char* bytes, size_t size) {
MD5Update(&md5_context_, bytes, static_cast<unsigned>(size));
}
-void MachoID::Update(MachoWalker *walker, off_t offset, size_t size) {
+void MachoID::Update(MachoWalker* walker, off_t offset, size_t size) {
if (!update_function_ || !size)
return;
@@ -237,7 +237,7 @@
bool MachoID::WalkHeader(cpu_type_t cpu_type,
cpu_subtype_t cpu_subtype,
MachoWalker::LoadCommandCallback callback,
- void *context) {
+ void* context) {
if (memory_) {
MachoWalker walker(memory_, memory_size_, callback, context);
return walker.WalkHeader(cpu_type, cpu_subtype);
@@ -248,9 +248,9 @@
}
// static
-bool MachoID::WalkerCB(MachoWalker *walker, load_command *cmd, off_t offset,
- bool swap, void *context) {
- MachoID *macho_id = (MachoID *)context;
+bool MachoID::WalkerCB(MachoWalker* walker, load_command* cmd, off_t offset,
+ bool swap, void* context) {
+ MachoID* macho_id = (MachoID*)context;
if (cmd->cmd == LC_SEGMENT) {
struct segment_command seg;
@@ -327,11 +327,11 @@
}
// static
-bool MachoID::UUIDWalkerCB(MachoWalker *walker, load_command *cmd, off_t offset,
- bool swap, void *context) {
+bool MachoID::UUIDWalkerCB(MachoWalker* walker, load_command* cmd, off_t offset,
+ bool swap, void* context) {
if (cmd->cmd == LC_UUID) {
- struct breakpad_uuid_command *uuid_cmd =
- (struct breakpad_uuid_command *)context;
+ struct breakpad_uuid_command* uuid_cmd =
+ (struct breakpad_uuid_command*)context;
if (!walker->ReadBytes(uuid_cmd, sizeof(struct breakpad_uuid_command),
offset))
@@ -348,10 +348,10 @@
}
// static
-bool MachoID::IDWalkerCB(MachoWalker *walker, load_command *cmd, off_t offset,
- bool swap, void *context) {
+bool MachoID::IDWalkerCB(MachoWalker* walker, load_command* cmd, off_t offset,
+ bool swap, void* context) {
if (cmd->cmd == LC_ID_DYLIB) {
- struct dylib_command *dylib_cmd = (struct dylib_command *)context;
+ struct dylib_command* dylib_cmd = (struct dylib_command*)context;
if (!walker->ReadBytes(dylib_cmd, sizeof(struct dylib_command), offset))
return false;
diff --git a/src/common/mac/macho_id.h b/src/common/mac/macho_id.h
index 1037549..e8874c3 100644
--- a/src/common/mac/macho_id.h
+++ b/src/common/mac/macho_id.h
@@ -45,8 +45,8 @@
class MachoID {
public:
- MachoID(const char *path);
- MachoID(const char *path, void *memory, size_t size);
+ MachoID(const char* path);
+ MachoID(const char* path, void* memory, size_t size);
~MachoID();
// For the given |cpu_type| and |cpu_subtype|, return a UUID from the LC_UUID
@@ -78,40 +78,40 @@
private:
// Signature of class member function to be called with data read from file
- typedef void (MachoID::*UpdateFunction)(unsigned char *bytes, size_t size);
+ typedef void (MachoID::*UpdateFunction)(unsigned char* bytes, size_t size);
// Update the CRC value by examining |size| |bytes| and applying the algorithm
// to each byte.
- void UpdateCRC(unsigned char *bytes, size_t size);
+ void UpdateCRC(unsigned char* bytes, size_t size);
// Update the MD5 value by examining |size| |bytes| and applying the algorithm
// to each byte.
- void UpdateMD5(unsigned char *bytes, size_t size);
+ void UpdateMD5(unsigned char* bytes, size_t size);
// Bottleneck for update routines
- void Update(MachoWalker *walker, off_t offset, size_t size);
+ void Update(MachoWalker* walker, off_t offset, size_t size);
// Factory for the MachoWalker
bool WalkHeader(cpu_type_t cpu_type, cpu_subtype_t cpu_subtype,
- MachoWalker::LoadCommandCallback callback, void *context);
+ MachoWalker::LoadCommandCallback callback, void* context);
// The callback from the MachoWalker for CRC and MD5
- static bool WalkerCB(MachoWalker *walker, load_command *cmd, off_t offset,
- bool swap, void *context);
+ static bool WalkerCB(MachoWalker* walker, load_command* cmd, off_t offset,
+ bool swap, void* context);
// The callback from the MachoWalker for LC_UUID
- static bool UUIDWalkerCB(MachoWalker *walker, load_command *cmd, off_t offset,
- bool swap, void *context);
+ static bool UUIDWalkerCB(MachoWalker* walker, load_command* cmd, off_t offset,
+ bool swap, void* context);
// The callback from the MachoWalker for LC_ID_DYLIB
- static bool IDWalkerCB(MachoWalker *walker, load_command *cmd, off_t offset,
- bool swap, void *context);
+ static bool IDWalkerCB(MachoWalker* walker, load_command* cmd, off_t offset,
+ bool swap, void* context);
// File path
char path_[PATH_MAX];
// Memory region to read from
- void *memory_;
+ void* memory_;
// Size of the memory region
size_t memory_size_;
diff --git a/src/common/mac/macho_reader.cc b/src/common/mac/macho_reader.cc
index 91e1fdd..b42506c 100644
--- a/src/common/mac/macho_reader.cc
+++ b/src/common/mac/macho_reader.cc
@@ -81,7 +81,7 @@
" to contain\n", filename_.c_str());
}
-bool FatReader::Read(const uint8_t *buffer, size_t size) {
+bool FatReader::Read(const uint8_t* buffer, size_t size) {
buffer_.start = buffer;
buffer_.end = buffer + size;
ByteCursor cursor(&buffer_);
@@ -196,19 +196,19 @@
filename_.c_str(), i, type);
}
-void Reader::Reporter::SectionsMissing(const string &name) {
+void Reader::Reporter::SectionsMissing(const string& name) {
fprintf(stderr, "%s: the load command for segment '%s'"
" is too short to hold the section headers it claims to have\n",
filename_.c_str(), name.c_str());
}
-void Reader::Reporter::MisplacedSegmentData(const string &name) {
+void Reader::Reporter::MisplacedSegmentData(const string& name) {
fprintf(stderr, "%s: the segment '%s' claims its contents lie beyond"
" the end of the file\n", filename_.c_str(), name.c_str());
}
-void Reader::Reporter::MisplacedSectionData(const string §ion,
- const string &segment) {
+void Reader::Reporter::MisplacedSectionData(const string& section,
+ const string& segment) {
fprintf(stderr, "%s: the section '%s' in segment '%s'"
" claims its contents lie outside the segment's contents\n",
filename_.c_str(), section.c_str(), segment.c_str());
@@ -225,7 +225,7 @@
filename_.c_str(), cpu_type);
}
-bool Reader::Read(const uint8_t *buffer,
+bool Reader::Read(const uint8_t* buffer,
size_t size,
cpu_type_t expected_cpu_type,
cpu_subtype_t expected_cpu_subtype) {
@@ -309,7 +309,7 @@
return true;
}
-bool Reader::WalkLoadCommands(Reader::LoadCommandHandler *handler) const {
+bool Reader::WalkLoadCommands(Reader::LoadCommandHandler* handler) const {
ByteCursor list_cursor(&load_commands_, big_endian_);
for (size_t index = 0; index < load_command_count_; ++index) {
@@ -422,13 +422,13 @@
public:
// Create a load command handler that looks for a segment named NAME,
// and sets SEGMENT to describe it if found.
- SegmentFinder(const string &name, Segment *segment)
+ SegmentFinder(const string& name, Segment* segment)
: name_(name), segment_(segment), found_() { }
// Return true if the traversal found the segment, false otherwise.
bool found() const { return found_; }
- bool SegmentCommand(const Segment &segment) {
+ bool SegmentCommand(const Segment& segment) {
if (segment.name == name_) {
*segment_ = segment;
found_ = true;
@@ -439,23 +439,23 @@
private:
// The name of the segment our creator is looking for.
- const string &name_;
+ const string& name_;
// Where we should store the segment if found. (WEAK)
- Segment *segment_;
+ Segment* segment_;
// True if we found the segment.
bool found_;
};
-bool Reader::FindSegment(const string &name, Segment *segment) const {
+bool Reader::FindSegment(const string& name, Segment* segment) const {
SegmentFinder finder(name, segment);
WalkLoadCommands(&finder);
return finder.found();
}
-bool Reader::WalkSegmentSections(const Segment &segment,
- SectionHandler *handler) const {
+bool Reader::WalkSegmentSections(const Segment& segment,
+ SectionHandler* handler) const {
size_t word_size = segment.bits_64 ? 8 : 4;
ByteCursor cursor(&segment.section_list, big_endian_);
@@ -537,18 +537,18 @@
public:
// Create a SectionHandler that populates MAP with an entry for
// each section it is given.
- SectionMapper(SectionMap *map) : map_(map) { }
- bool HandleSection(const Section §ion) {
+ SectionMapper(SectionMap* map) : map_(map) { }
+ bool HandleSection(const Section& section) {
(*map_)[section.section_name] = section;
return true;
}
private:
// The map under construction. (WEAK)
- SectionMap *map_;
+ SectionMap* map_;
};
-bool Reader::MapSegmentSections(const Segment &segment,
- SectionMap *section_map) const {
+bool Reader::MapSegmentSections(const Segment& segment,
+ SectionMap* section_map) const {
section_map->clear();
SectionMapper mapper(section_map);
return WalkSegmentSections(segment, &mapper);
diff --git a/src/common/mac/macho_reader.h b/src/common/mac/macho_reader.h
index 145d17d..02762c5 100644
--- a/src/common/mac/macho_reader.h
+++ b/src/common/mac/macho_reader.h
@@ -78,7 +78,7 @@
class Reporter {
public:
// Create a reporter that attributes problems to |filename|.
- explicit Reporter(const string &filename) : filename_(filename) { }
+ explicit Reporter(const string& filename) : filename_(filename) { }
virtual ~Reporter() { }
@@ -101,7 +101,7 @@
};
// Create a fat binary file reader that uses |reporter| to report problems.
- explicit FatReader(Reporter *reporter) : reporter_(reporter) { }
+ explicit FatReader(Reporter* reporter) : reporter_(reporter) { }
// Read the |size| bytes at |buffer| as a fat binary file. On success,
// return true; on failure, report the problem to reporter_ and return
@@ -110,7 +110,7 @@
// If the data is a plain Mach-O file, rather than a fat binary file,
// then the reader behaves as if it had found a fat binary file whose
// single object file is the Mach-O file.
- bool Read(const uint8_t *buffer, size_t size);
+ bool Read(const uint8_t* buffer, size_t size);
// Return an array of 'SuperFatArch' structures describing the
// object files present in this fat binary file. Set |size| to the
@@ -130,7 +130,7 @@
// possible to use the result with OS X functions like NXFindBestFatArch,
// so that the symbol dumper will behave consistently with other OS X
// utilities that work with fat binaries.
- const SuperFatArch* object_files(size_t *count) const {
+ const SuperFatArch* object_files(size_t* count) const {
*count = object_files_.size();
if (object_files_.size() > 0)
return &object_files_[0];
@@ -139,7 +139,7 @@
private:
// We use this to report problems parsing the file's contents. (WEAK)
- Reporter *reporter_;
+ Reporter* reporter_;
// The contents of the fat binary or Mach-O file we're parsing. We do not
// own the storage it refers to.
@@ -240,7 +240,7 @@
class Reporter {
public:
// Create a reporter that attributes problems to |filename|.
- explicit Reporter(const string &filename) : filename_(filename) { }
+ explicit Reporter(const string& filename) : filename_(filename) { }
virtual ~Reporter() { }
// Reporter functions for fatal errors return void; the reader will
@@ -282,16 +282,16 @@
// The LC_SEGMENT or LC_SEGMENT_64 load command for the segment named
// |name| is too short to hold the sections that its header says it does.
// (This more specific than LoadCommandTooShort.)
- virtual void SectionsMissing(const string &name);
+ virtual void SectionsMissing(const string& name);
// The segment named |name| claims that its contents lie beyond the end
// of the file.
- virtual void MisplacedSegmentData(const string &name);
+ virtual void MisplacedSegmentData(const string& name);
// The section named |section| in the segment named |segment| claims that
// its contents do not lie entirely within the segment.
- virtual void MisplacedSectionData(const string §ion,
- const string &segment);
+ virtual void MisplacedSectionData(const string& section,
+ const string& segment);
// The LC_SYMTAB command claims that symbol table contents are located
// beyond the end of the file.
@@ -315,7 +315,7 @@
// Called to report that the segment's section list contains |section|.
// This should return true if the iteration should continue, or false
// if it should stop.
- virtual bool HandleSection(const Section §ion) = 0;
+ virtual bool HandleSection(const Section& section) = 0;
};
// A handler for the load commands in a Mach-O file.
@@ -341,20 +341,20 @@
// cannot parse the command type or its size, we call
// reporter_->IncompleteLoadCommand instead.)
virtual bool UnknownCommand(LoadCommandType type,
- const ByteBuffer &contents) {
+ const ByteBuffer& contents) {
return true;
}
// The load command is LC_SEGMENT or LC_SEGMENT_64, defining a segment
// with the properties given in |segment|.
- virtual bool SegmentCommand(const Segment &segment) {
+ virtual bool SegmentCommand(const Segment& segment) {
return true;
}
// The load command is LC_SYMTAB. |entries| holds the array of nlist
// entries, and |names| holds the strings the entries refer to.
- virtual bool SymtabCommand(const ByteBuffer &entries,
- const ByteBuffer &names) {
+ virtual bool SymtabCommand(const ByteBuffer& entries,
+ const ByteBuffer& names) {
return true;
}
@@ -362,7 +362,7 @@
};
// Create a Mach-O file reader that reports problems to |reporter|.
- explicit Reader(Reporter *reporter)
+ explicit Reader(Reporter* reporter)
: reporter_(reporter) { }
// Read the given data as a Mach-O file. The reader retains pointers
@@ -371,11 +371,11 @@
//
// At most one of these functions should be invoked once on each Reader
// instance.
- bool Read(const uint8_t *buffer,
+ bool Read(const uint8_t* buffer,
size_t size,
cpu_type_t expected_cpu_type,
cpu_subtype_t expected_cpu_subtype);
- bool Read(const ByteBuffer &buffer,
+ bool Read(const ByteBuffer& buffer,
cpu_type_t expected_cpu_type,
cpu_subtype_t expected_cpu_subtype) {
return Read(buffer.start,
@@ -402,25 +402,25 @@
// a handler function returns false. If we encounter a malformed load
// command, report it via reporter_ and return false. Return true if all
// load commands were parseable and all handlers returned true.
- bool WalkLoadCommands(LoadCommandHandler *handler) const;
+ bool WalkLoadCommands(LoadCommandHandler* handler) const;
// Set |segment| to describe the segment named |name|, if present. If
// found, |segment|'s byte buffers refer to a subregion of the bytes
// passed to Read. If we find the section, return true; otherwise,
// return false.
- bool FindSegment(const string &name, Segment *segment) const;
+ bool FindSegment(const string& name, Segment* segment) const;
// Apply |handler| to each section defined in |segment|. If |handler| returns
// false, stop iterating and return false. If all calls to |handler| return
// true and we reach the end of the section list, return true.
- bool WalkSegmentSections(const Segment &segment, SectionHandler *handler)
+ bool WalkSegmentSections(const Segment& segment, SectionHandler* handler)
const;
// Clear |section_map| and then populate it with a map of the sections
// in |segment|, from section names to Section structures.
// Each Section's contents refer to bytes in |segment|'s contents.
// On success, return true; if a problem occurs, report it and return false.
- bool MapSegmentSections(const Segment &segment, SectionMap *section_map)
+ bool MapSegmentSections(const Segment& segment, SectionMap* section_map)
const;
private:
@@ -429,7 +429,7 @@
class SectionMapper;
// We use this to report problems parsing the file's contents. (WEAK)
- Reporter *reporter_;
+ Reporter* reporter_;
// The contents of the Mach-O file we're parsing. We do not own the
// storage it refers to.
diff --git a/src/common/mac/macho_reader_unittest.cc b/src/common/mac/macho_reader_unittest.cc
index d8459d8..dccda4e 100644
--- a/src/common/mac/macho_reader_unittest.cc
+++ b/src/common/mac/macho_reader_unittest.cc
@@ -75,7 +75,7 @@
class MockFatReaderReporter: public FatReader::Reporter {
public:
- MockFatReaderReporter(const string &filename)
+ MockFatReaderReporter(const string& filename)
: FatReader::Reporter(filename) { }
MOCK_METHOD0(BadHeader, void());
MOCK_METHOD0(MisplacedObjectFile, void());
@@ -84,7 +84,7 @@
class MockReaderReporter: public Reader::Reporter {
public:
- MockReaderReporter(const string &filename) : Reader::Reporter(filename) { }
+ MockReaderReporter(const string& filename) : Reader::Reporter(filename) { }
MOCK_METHOD0(BadHeader, void());
MOCK_METHOD4(CPUTypeMismatch, void(cpu_type_t cpu_type,
cpu_subtype_t cpu_subtype,
@@ -95,24 +95,24 @@
MOCK_METHOD3(LoadCommandsOverrun, void(size_t claimed, size_t i,
LoadCommandType type));
MOCK_METHOD2(LoadCommandTooShort, void(size_t i, LoadCommandType type));
- MOCK_METHOD1(SectionsMissing, void(const string &name));
- MOCK_METHOD1(MisplacedSegmentData, void(const string &name));
- MOCK_METHOD2(MisplacedSectionData, void(const string §ion,
- const string &segment));
+ MOCK_METHOD1(SectionsMissing, void(const string& name));
+ MOCK_METHOD1(MisplacedSegmentData, void(const string& name));
+ MOCK_METHOD2(MisplacedSectionData, void(const string& section,
+ const string& segment));
MOCK_METHOD0(MisplacedSymbolTable, void());
MOCK_METHOD1(UnsupportedCPUType, void(cpu_type_t cpu_type));
};
class MockLoadCommandHandler: public Reader::LoadCommandHandler {
public:
- MOCK_METHOD2(UnknownCommand, bool(LoadCommandType, const ByteBuffer &));
- MOCK_METHOD1(SegmentCommand, bool(const Segment &));
- MOCK_METHOD2(SymtabCommand, bool(const ByteBuffer &, const ByteBuffer &));
+ MOCK_METHOD2(UnknownCommand, bool(LoadCommandType, const ByteBuffer&));
+ MOCK_METHOD1(SegmentCommand, bool(const Segment&));
+ MOCK_METHOD2(SymtabCommand, bool(const ByteBuffer&, const ByteBuffer&));
};
class MockSectionHandler: public Reader::SectionHandler {
public:
- MOCK_METHOD1(HandleSection, bool(const Section §ion));
+ MOCK_METHOD1(HandleSection, bool(const Section& section));
};
@@ -221,7 +221,7 @@
}
void ReadFat(bool expect_parse_success = true) {
ASSERT_TRUE(fat.GetContents(&contents));
- fat_bytes = reinterpret_cast<const uint8_t *>(contents.data());
+ fat_bytes = reinterpret_cast<const uint8_t*>(contents.data());
if (expect_parse_success) {
EXPECT_TRUE(reader.Read(fat_bytes, contents.size()));
size_t fat_files_count;
@@ -238,7 +238,7 @@
MockFatReaderReporter reporter;
FatReader reader;
string contents;
- const uint8_t *fat_bytes;
+ const uint8_t* fat_bytes;
vector<struct fat_arch> object_files;
};
@@ -487,16 +487,16 @@
private:
// The innermost WithConfiguration in whose dynamic scope we are
// currently executing.
- static WithConfiguration *current_;
+ static WithConfiguration* current_;
// The innermost WithConfiguration whose dynamic scope encloses this
// WithConfiguration.
Endianness endianness_;
size_t word_size_;
- WithConfiguration *saved_;
+ WithConfiguration* saved_;
};
-WithConfiguration *WithConfiguration::current_ = NULL;
+WithConfiguration* WithConfiguration::current_ = NULL;
// A test_assembler::Section with a size that we can cite. The start(),
// Here() and Mark() member functions of a SizedSection always represent
@@ -527,7 +527,7 @@
// Append SECTION to the end of this section, and call its Finish member.
// Return a reference to this section.
- SizedSection &Place(SizedSection *section) {
+ SizedSection& Place(SizedSection* section) {
assert(section->endianness() == endianness());
section->Finish();
section->start() = Here();
@@ -563,7 +563,7 @@
// Placing a loaded section within a loaded section sets the relationship
// between their addresses.
- LoadedSection &Place(LoadedSection *section) {
+ LoadedSection& Place(LoadedSection* section) {
section->address() = address() + Size();
SizedSection::Place(section);
return *this;
@@ -583,7 +583,7 @@
// The load command will refer to CONTENTS, which must be Placed in the
// file separately, at the desired position. Return a reference to this
// section.
- SegmentLoadCommand &Header(const string &name, const LoadedSection &contents,
+ SegmentLoadCommand& Header(const string& name, const LoadedSection& contents,
uint32_t maxprot, uint32_t initprot,
uint32_t flags) {
assert(contents.word_size() == word_size());
@@ -608,16 +608,16 @@
// memory. If this label is still undefined by the time we place this
// segment, it defaults to the final size of the segment's in-file
// contents. Return a reference to this load command.
- Label &vmsize() { return vmsize_; }
+ Label& vmsize() { return vmsize_; }
// Add a section entry with the given characteristics to this segment
// load command. Return a reference to this. The section entry will refer
// to CONTENTS, which must be Placed in the segment's contents
// separately, at the desired position.
- SegmentLoadCommand &AppendSectionEntry(const string §ion_name,
- const string &segment_name,
+ SegmentLoadCommand& AppendSectionEntry(const string& section_name,
+ const string& segment_name,
uint32_t alignment, uint32_t flags,
- const LoadedSection &contents) {
+ const LoadedSection& contents) {
AppendCString(section_name, 16);
AppendCString(segment_name, 16);
Append(endianness(), word_size() / 8, contents.address());
@@ -671,14 +671,14 @@
Label final_command_count() const { return final_command_count_; }
// Increment the command count; return a reference to this section.
- LoadCommands &CountCommand() {
+ LoadCommands& CountCommand() {
command_count_++;
return *this;
}
// Place COMMAND, containing a load command, at the end of this section.
// Return a reference to this section.
- LoadCommands &Place(SizedSection *section) {
+ LoadCommands& Place(SizedSection* section) {
SizedSection::Place(section);
CountCommand();
return *this;
@@ -710,7 +710,7 @@
// Create a Mach-O file header using the given characteristics and load
// command list. This Places COMMANDS immediately after the header.
// Return a reference to this section.
- MachOFile &Header(LoadCommands *commands,
+ MachOFile& Header(LoadCommands* commands,
cpu_type_t cpu_type = CPU_TYPE_X86,
cpu_subtype_t cpu_subtype = CPU_SUBTYPE_I386_ALL,
FileType file_type = MH_EXECUTE,
@@ -752,12 +752,12 @@
EXPECT_CALL(load_command_handler, SegmentCommand(_)).Times(0);
}
- void ReadFile(MachOFile *file,
+ void ReadFile(MachOFile* file,
bool expect_parse_success,
cpu_type_t expected_cpu_type,
cpu_subtype_t expected_cpu_subtype) {
ASSERT_TRUE(file->GetContents(&file_contents));
- file_bytes = reinterpret_cast<const uint8_t *>(file_contents.data());
+ file_bytes = reinterpret_cast<const uint8_t*>(file_contents.data());
if (expect_parse_success) {
EXPECT_TRUE(reader.Read(file_bytes,
file_contents.size(),
@@ -772,7 +772,7 @@
}
string file_contents;
- const uint8_t *file_bytes;
+ const uint8_t* file_bytes;
MockReaderReporter reporter;
Reader reader;
MockLoadCommandHandler load_command_handler;
@@ -1343,14 +1343,14 @@
EXPECT_TRUE(reader.WalkLoadCommands(&load_command_handler));
}
-static inline Matcher<const Section &> MatchSection(
+static inline Matcher<const Section&> MatchSection(
Matcher<bool> bits_64,
- Matcher<const string &> section_name,
- Matcher<const string &> segment_name,
+ Matcher<const string&> section_name,
+ Matcher<const string&> segment_name,
Matcher<uint64_t> address,
Matcher<uint32_t> alignment,
Matcher<uint32_t> flags,
- Matcher<const ByteBuffer &> contents) {
+ Matcher<const ByteBuffer&> contents) {
return AllOf(AllOf(Field(&Section::bits_64, bits_64),
Field(&Section::section_name, section_name),
Field(&Section::segment_name, segment_name),
@@ -1360,10 +1360,10 @@
Field(&Section::contents, contents)));
}
-static inline Matcher<const Section &> MatchSection(
+static inline Matcher<const Section&> MatchSection(
Matcher<bool> bits_64,
- Matcher<const string &> section_name,
- Matcher<const string &> segment_name,
+ Matcher<const string&> section_name,
+ Matcher<const string&> segment_name,
Matcher<uint64_t> address) {
return AllOf(Field(&Section::bits_64, bits_64),
Field(&Section::section_name, section_name),
@@ -1410,7 +1410,7 @@
contents1.start = file_bytes + section1.start().Value();
contents1.end = contents1.start + section1.final_size().Value();
EXPECT_EQ("buddha's hand",
- string(reinterpret_cast<const char *>(contents1.start),
+ string(reinterpret_cast<const char*>(contents1.start),
contents1.Size()));
EXPECT_CALL(section_handler,
HandleSection(MatchSection(true, "mandarin", "kishu",
@@ -1422,7 +1422,7 @@
contents2.start = file_bytes + section2.start().Value();
contents2.end = contents2.start + section2.final_size().Value();
EXPECT_EQ("kumquat",
- string(reinterpret_cast<const char *>(contents2.start),
+ string(reinterpret_cast<const char*>(contents2.start),
contents2.Size()));
EXPECT_CALL(section_handler,
HandleSection(MatchSection(true, "bergamot", "cara cara",
@@ -1716,7 +1716,7 @@
public:
// Add the string S to this StringAssembler, and return the string's
// offset within this compilation unit's strings.
- size_t Add(const string &s) {
+ size_t Add(const string& s) {
size_t offset = Size();
AppendCString(s);
return offset;
@@ -1728,7 +1728,7 @@
class SymbolAssembler: public SizedSection {
public:
// Create a SymbolAssembler that uses StringAssembler for its strings.
- explicit SymbolAssembler(StringAssembler *string_assembler)
+ explicit SymbolAssembler(StringAssembler* string_assembler)
: string_assembler_(string_assembler),
entry_count_(0) { }
@@ -1737,7 +1737,7 @@
// its compilation unit's portion of the .stabstr section; this can be a
// value generated by a StringAssembler. Return a reference to this
// SymbolAssembler.
- SymbolAssembler &Symbol(uint8_t type, uint8_t other, Label descriptor,
+ SymbolAssembler& Symbol(uint8_t type, uint8_t other, Label descriptor,
Label value, Label name) {
D32(name);
D8(type);
@@ -1749,14 +1749,14 @@
}
// As above, but automatically add NAME to our StringAssembler.
- SymbolAssembler &Symbol(uint8_t type, uint8_t other, Label descriptor,
- Label value, const string &name) {
+ SymbolAssembler& Symbol(uint8_t type, uint8_t other, Label descriptor,
+ Label value, const string& name) {
return Symbol(type, other, descriptor, value, string_assembler_->Add(name));
}
private:
// The strings for our STABS entries.
- StringAssembler *string_assembler_;
+ StringAssembler* string_assembler_;
// The number of entries in this compilation unit so far.
size_t entry_count_;
diff --git a/src/common/mac/macho_walker.cc b/src/common/mac/macho_walker.cc
index 1acd866..a42128b 100644
--- a/src/common/mac/macho_walker.cc
+++ b/src/common/mac/macho_walker.cc
@@ -47,8 +47,8 @@
namespace MacFileUtilities {
-MachoWalker::MachoWalker(const char *path, LoadCommandCallback callback,
- void *context)
+MachoWalker::MachoWalker(const char* path, LoadCommandCallback callback,
+ void* context)
: file_(-1),
memory_(NULL),
memory_size_(0),
@@ -60,8 +60,8 @@
file_ = open(path, O_RDONLY);
}
-MachoWalker::MachoWalker(void *memory, size_t size,
- LoadCommandCallback callback, void *context)
+MachoWalker::MachoWalker(void* memory, size_t size,
+ LoadCommandCallback callback, void* context)
: file_(-1),
memory_(memory),
memory_size_(size),
@@ -82,7 +82,7 @@
cpu_subtype_t valid_cpu_subtype = cpu_subtype;
// if |cpu_type| is 0, use the native cpu type.
if (cpu_type == 0) {
- const NXArchInfo *arch = NXGetLocalArchInfo();
+ const NXArchInfo* arch = NXGetLocalArchInfo();
assert(arch);
valid_cpu_type = arch->cputype;
valid_cpu_subtype = CPU_SUBTYPE_MULTIPLE;
@@ -98,7 +98,7 @@
return false;
}
-bool MachoWalker::ReadBytes(void *buffer, size_t size, off_t offset) {
+bool MachoWalker::ReadBytes(void* buffer, size_t size, off_t offset) {
if (memory_) {
if (offset < 0)
return false;
@@ -109,14 +109,14 @@
size = memory_size_ - static_cast<size_t>(offset);
result = false;
}
- memcpy(buffer, static_cast<char *>(memory_) + offset, size);
+ memcpy(buffer, static_cast<char*>(memory_) + offset, size);
return result;
} else {
return pread(file_, buffer, size, offset) == (ssize_t)size;
}
}
-bool MachoWalker::CurrentHeader(struct mach_header_64 *header, off_t *offset) {
+bool MachoWalker::CurrentHeader(struct mach_header_64* header, off_t* offset) {
if (current_header_) {
memcpy(header, current_header_, sizeof(mach_header_64));
*offset = current_header_offset_;
@@ -128,7 +128,7 @@
bool MachoWalker::FindHeader(cpu_type_t cpu_type,
cpu_subtype_t cpu_subtype,
- off_t &offset) {
+ off_t& offset) {
// Read the magic bytes that's common amongst all mach-o files
uint32_t magic;
if (!ReadBytes(&magic, sizeof(magic), 0))
@@ -211,7 +211,7 @@
// Copy the data into the mach_header_64 structure. Since the 32-bit and
// 64-bit only differ in the last field (reserved), this is safe to do.
struct mach_header_64 header64;
- memcpy((void *)&header64, (const void *)&header, sizeof(header));
+ memcpy((void*)&header64, (const void*)&header, sizeof(header));
header64.reserved = 0;
current_header_ = &header64;
diff --git a/src/common/mac/macho_walker.h b/src/common/mac/macho_walker.h
index dd53581..168f30e 100644
--- a/src/common/mac/macho_walker.h
+++ b/src/common/mac/macho_walker.h
@@ -49,12 +49,12 @@
// beginning of the file (not header) where the command was read. If |swap|
// is set, then any command data (other than the returned load_command) should
// be swapped when read
- typedef bool (*LoadCommandCallback)(MachoWalker *walker, load_command *cmd,
- off_t offset, bool swap, void *context);
+ typedef bool (*LoadCommandCallback)(MachoWalker* walker, load_command* cmd,
+ off_t offset, bool swap, void* context);
- MachoWalker(const char *path, LoadCommandCallback callback, void *context);
- MachoWalker(void *memory, size_t size, LoadCommandCallback callback,
- void *context);
+ MachoWalker(const char* path, LoadCommandCallback callback, void* context);
+ MachoWalker(void* memory, size_t size, LoadCommandCallback callback,
+ void* context);
~MachoWalker();
// Begin walking the header for |cpu_type| and |cpu_subtype|. If |cpu_type|
@@ -67,17 +67,17 @@
bool WalkHeader(cpu_type_t cpu_type, cpu_subtype_t cpu_subtype);
// Read |size| bytes from the opened file at |offset| into |buffer|
- bool ReadBytes(void *buffer, size_t size, off_t offset);
+ bool ReadBytes(void* buffer, size_t size, off_t offset);
// Return the current header and header offset
- bool CurrentHeader(struct mach_header_64 *header, off_t *offset);
+ bool CurrentHeader(struct mach_header_64* header, off_t* offset);
private:
// Locate (if any) the header offset for |cpu_type| and return in |offset|.
// Return true if found, false otherwise.
bool FindHeader(cpu_type_t cpu_type,
cpu_subtype_t cpu_subtype,
- off_t &offset);
+ off_t& offset);
// Process an individual header starting at |offset| from the start of the
// file. Return true if successful, false otherwise.
@@ -91,27 +91,27 @@
int file_;
// Memory location to read from.
- void *memory_;
+ void* memory_;
// Size of the memory segment we can read from.
size_t memory_size_;
// User specified callback & context
LoadCommandCallback callback_;
- void *callback_context_;
+ void* callback_context_;
// Current header, size, and offset. The mach_header_64 is used for both
// 32-bit and 64-bit headers because they only differ in their last field
// (reserved). By adding the |current_header_size_| and the
// |current_header_offset_|, you can determine the offset in the file just
// after the header.
- struct mach_header_64 *current_header_;
+ struct mach_header_64* current_header_;
unsigned long current_header_size_;
off_t current_header_offset_;
private:
- MachoWalker(const MachoWalker &);
- MachoWalker &operator=(const MachoWalker &);
+ MachoWalker(const MachoWalker&);
+ MachoWalker& operator=(const MachoWalker&);
};
} // namespace MacFileUtilities
diff --git a/src/common/mac/string_utilities.cc b/src/common/mac/string_utilities.cc
index 07c0f42..cb15540 100644
--- a/src/common/mac/string_utilities.cc
+++ b/src/common/mac/string_utilities.cc
@@ -48,12 +48,12 @@
CFStringGetBytes(str, CFRangeMake(0, length), kCFStringEncodingUTF8, 0,
false, buffer.get(), maxUTF8Length, &actualUTF8Length);
buffer[actualUTF8Length] = 0;
- result.assign((const char *)buffer.get());
+ result.assign((const char*)buffer.get());
return result;
}
-unsigned int IntegerValueAtIndex(string &str, unsigned int idx) {
+unsigned int IntegerValueAtIndex(string& str, unsigned int idx) {
string digits("0123456789"), temp;
size_t start = 0;
size_t end;
diff --git a/src/common/mac/string_utilities.h b/src/common/mac/string_utilities.h
index 6d89c83..e87304c 100644
--- a/src/common/mac/string_utilities.h
+++ b/src/common/mac/string_utilities.h
@@ -45,7 +45,7 @@
// Return the idx'th decimal integer in str, separated by non-decimal-digits
// E.g., str = 10.4.8, idx = 1 -> 4
-unsigned int IntegerValueAtIndex(string &str, unsigned int idx);
+unsigned int IntegerValueAtIndex(string& str, unsigned int idx);
} // namespace MacStringUtils
diff --git a/src/common/mac/super_fat_arch.h b/src/common/mac/super_fat_arch.h
index 501c865..d7fa018 100644
--- a/src/common/mac/super_fat_arch.h
+++ b/src/common/mac/super_fat_arch.h
@@ -57,7 +57,7 @@
align(0) {
}
- explicit SuperFatArch(const struct fat_arch &arch) :
+ explicit SuperFatArch(const struct fat_arch& arch) :
cputype(arch.cputype),
cpusubtype(arch.cpusubtype),
offset(arch.offset),
diff --git a/src/common/md5.cc b/src/common/md5.cc
index 4f1ac8c..b6e710d 100644
--- a/src/common/md5.cc
+++ b/src/common/md5.cc
@@ -31,7 +31,7 @@
do {
t = (u32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
((unsigned) buf[1] << 8 | buf[0]);
- *(u32 *) buf = t;
+ *(u32*) buf = t;
buf += 4;
} while (--longs);
}
@@ -74,7 +74,7 @@
/* Handle any leading odd-sized chunks */
if (t) {
- unsigned char *p = (unsigned char *) ctx->in + t;
+ unsigned char *p = (unsigned char*) ctx->in + t;
t = 64 - t;
if (len < t) {
@@ -83,7 +83,7 @@
}
memcpy(p, buf, t);
byteReverse(ctx->in, 16);
- MD5Transform(ctx->buf, (u32 *) ctx->in);
+ MD5Transform(ctx->buf, (u32*) ctx->in);
buf += t;
len -= t;
}
@@ -92,7 +92,7 @@
while (len >= 64) {
memcpy(ctx->in, buf, 64);
byteReverse(ctx->in, 16);
- MD5Transform(ctx->buf, (u32 *) ctx->in);
+ MD5Transform(ctx->buf, (u32*) ctx->in);
buf += 64;
len -= 64;
}
@@ -127,7 +127,7 @@
/* Two lots of padding: Pad the first block to 64 bytes */
memset(p, 0, count);
byteReverse(ctx->in, 16);
- MD5Transform(ctx->buf, (u32 *) ctx->in);
+ MD5Transform(ctx->buf, (u32*) ctx->in);
/* Now fill the next block with 56 bytes */
memset(ctx->in, 0, 56);
@@ -141,8 +141,8 @@
memcpy(&ctx->in[14], &ctx->bits[0], sizeof(u32));
memcpy(&ctx->in[15], &ctx->bits[1], sizeof(u32));
- MD5Transform(ctx->buf, (u32 *) ctx->in);
- byteReverse((unsigned char *) ctx->buf, 4);
+ MD5Transform(ctx->buf, (u32*) ctx->in);
+ byteReverse((unsigned char*) ctx->buf, 4);
memcpy(digest, ctx->buf, 16);
memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */
}
diff --git a/src/common/memory_allocator.h b/src/common/memory_allocator.h
index a3159ea..69055a1 100644
--- a/src/common/memory_allocator.h
+++ b/src/common/memory_allocator.h
@@ -71,12 +71,12 @@
FreeAll();
}
- void *Alloc(size_t bytes) {
+ void* Alloc(size_t bytes) {
if (!bytes)
return NULL;
if (current_page_ && page_size_ - page_offset_ >= bytes) {
- uint8_t *const ret = current_page_ + page_offset_;
+ uint8_t* const ret = current_page_ + page_offset_;
page_offset_ += bytes;
if (page_offset_ == page_size_) {
page_offset_ = 0;
@@ -88,7 +88,7 @@
const size_t pages =
(bytes + sizeof(PageHeader) + page_size_ - 1) / page_size_;
- uint8_t *const ret = GetNPages(pages);
+ uint8_t* const ret = GetNPages(pages);
if (!ret)
return NULL;
@@ -115,8 +115,8 @@
unsigned long pages_allocated() { return pages_allocated_; }
private:
- uint8_t *GetNPages(size_t num_pages) {
- void *a = sys_mmap(NULL, page_size_ * num_pages, PROT_READ | PROT_WRITE,
+ uint8_t* GetNPages(size_t num_pages) {
+ void* a = sys_mmap(NULL, page_size_ * num_pages, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (a == MAP_FAILED)
return NULL;
@@ -127,7 +127,7 @@
__msan_unpoison(a, page_size_ * num_pages);
#endif
- struct PageHeader *header = reinterpret_cast<PageHeader*>(a);
+ struct PageHeader* header = reinterpret_cast<PageHeader*>(a);
header->next = last_;
header->num_pages = num_pages;
last_ = header;
@@ -138,22 +138,22 @@
}
void FreeAll() {
- PageHeader *next;
+ PageHeader* next;
- for (PageHeader *cur = last_; cur; cur = next) {
+ for (PageHeader* cur = last_; cur; cur = next) {
next = cur->next;
sys_munmap(cur, cur->num_pages * page_size_);
}
}
struct PageHeader {
- PageHeader *next; // pointer to the start of the next set of pages.
+ PageHeader* next; // pointer to the start of the next set of pages.
size_t num_pages; // the number of pages in this set.
};
const size_t page_size_;
- PageHeader *last_;
- uint8_t *current_page_;
+ PageHeader* last_;
+ uint8_t* current_page_;
size_t page_offset_;
unsigned long pages_allocated_;
};
diff --git a/src/common/memory_allocator_unittest.cc b/src/common/memory_allocator_unittest.cc
index 43c8631..5803b90 100644
--- a/src/common/memory_allocator_unittest.cc
+++ b/src/common/memory_allocator_unittest.cc
@@ -46,7 +46,7 @@
EXPECT_EQ(0U, allocator.pages_allocated());
for (unsigned i = 1; i < 1024; ++i) {
- uint8_t *p = reinterpret_cast<uint8_t*>(allocator.Alloc(i));
+ uint8_t* p = reinterpret_cast<uint8_t*>(allocator.Alloc(i));
ASSERT_FALSE(p == NULL);
memset(p, 0, i);
}
@@ -56,11 +56,11 @@
PageAllocator allocator;
EXPECT_EQ(0U, allocator.pages_allocated());
- uint8_t *p = reinterpret_cast<uint8_t*>(allocator.Alloc(10000));
+ uint8_t* p = reinterpret_cast<uint8_t*>(allocator.Alloc(10000));
ASSERT_FALSE(p == NULL);
EXPECT_EQ(3U, allocator.pages_allocated());
for (unsigned i = 1; i < 10; ++i) {
- uint8_t *p = reinterpret_cast<uint8_t*>(allocator.Alloc(i));
+ uint8_t* p = reinterpret_cast<uint8_t*>(allocator.Alloc(i));
ASSERT_FALSE(p == NULL);
memset(p, 0, i);
}
diff --git a/src/common/module.cc b/src/common/module.cc
index aff2212..f70ae20 100644
--- a/src/common/module.cc
+++ b/src/common/module.cc
@@ -47,9 +47,9 @@
using std::hex;
-Module::Module(const string &name, const string &os,
- const string &architecture, const string &id,
- const string &code_id /* = "" */) :
+Module::Module(const string& name, const string& os,
+ const string& architecture, const string& id,
+ const string& code_id /* = "" */) :
name_(name),
os_(os),
architecture_(architecture),
@@ -64,7 +64,7 @@
it != functions_.end(); ++it) {
delete *it;
}
- for (vector<StackFrameEntry *>::iterator it = stack_frame_entries_.begin();
+ for (vector<StackFrameEntry*>::iterator it = stack_frame_entries_.begin();
it != stack_frame_entries_.end(); ++it) {
delete *it;
}
@@ -80,7 +80,7 @@
address_ranges_ = ranges;
}
-void Module::AddFunction(Function *function) {
+void Module::AddFunction(Function* function) {
// FUNC lines must not hold an empty name, so catch the problem early if
// callers try to add one.
assert(!function->name.empty());
@@ -124,13 +124,13 @@
}
}
-void Module::AddFunctions(vector<Function *>::iterator begin,
- vector<Function *>::iterator end) {
- for (vector<Function *>::iterator it = begin; it != end; ++it)
+void Module::AddFunctions(vector<Function*>::iterator begin,
+ vector<Function*>::iterator end) {
+ for (vector<Function*>::iterator it = begin; it != end; ++it)
AddFunction(*it);
}
-void Module::AddStackFrameEntry(StackFrameEntry *stack_frame_entry) {
+void Module::AddStackFrameEntry(StackFrameEntry* stack_frame_entry) {
if (!AddressIsInModule(stack_frame_entry->address)) {
return;
}
@@ -138,7 +138,7 @@
stack_frame_entries_.push_back(stack_frame_entry);
}
-void Module::AddExtern(Extern *ext) {
+void Module::AddExtern(Extern* ext) {
if (!AddressIsInModule(ext->address)) {
return;
}
@@ -151,17 +151,17 @@
}
}
-void Module::GetFunctions(vector<Function *> *vec,
- vector<Function *>::iterator i) {
+void Module::GetFunctions(vector<Function*>* vec,
+ vector<Function*>::iterator i) {
vec->insert(i, functions_.begin(), functions_.end());
}
-void Module::GetExterns(vector<Extern *> *vec,
- vector<Extern *>::iterator i) {
+void Module::GetExterns(vector<Extern*>* vec,
+ vector<Extern*>::iterator i) {
vec->insert(i, externs_.begin(), externs_.end());
}
-Module::File *Module::FindFile(const string &name) {
+Module::File* Module::FindFile(const string& name) {
// A tricky bit here. The key of each map entry needs to be a
// pointer to the entry's File's name string. This means that we
// can't do the initial lookup with any operation that would create
@@ -175,7 +175,7 @@
FileByNameMap::iterator destiny = files_.lower_bound(&name);
if (destiny == files_.end()
|| *destiny->first != name) { // Repeated string comparison, boo hoo.
- File *file = new File(name);
+ File* file = new File(name);
file->source_id = -1;
destiny = files_.insert(destiny,
FileByNameMap::value_type(&file->name, file));
@@ -183,23 +183,23 @@
return destiny->second;
}
-Module::File *Module::FindFile(const char *name) {
+Module::File* Module::FindFile(const char* name) {
string name_string = name;
return FindFile(name_string);
}
-Module::File *Module::FindExistingFile(const string &name) {
+Module::File* Module::FindExistingFile(const string& name) {
FileByNameMap::iterator it = files_.find(&name);
return (it == files_.end()) ? NULL : it->second;
}
-void Module::GetFiles(vector<File *> *vec) {
+void Module::GetFiles(vector<File*>* vec) {
vec->clear();
for (FileByNameMap::iterator it = files_.begin(); it != files_.end(); ++it)
vec->push_back(it->second);
}
-void Module::GetStackFrameEntries(vector<StackFrameEntry *> *vec) const {
+void Module::GetStackFrameEntries(vector<StackFrameEntry*>* vec) const {
*vec = stack_frame_entries_;
}
@@ -214,7 +214,7 @@
// info, by setting each one's source id to zero.
for (FunctionSet::const_iterator func_it = functions_.begin();
func_it != functions_.end(); ++func_it) {
- Function *func = *func_it;
+ Function* func = *func_it;
for (vector<Line>::iterator line_it = func->lines.begin();
line_it != func->lines.end(); ++line_it)
line_it->file->source_id = 0;
@@ -238,7 +238,7 @@
return false;
}
-bool Module::WriteRuleMap(const RuleMap &rule_map, std::ostream &stream) {
+bool Module::WriteRuleMap(const RuleMap& rule_map, std::ostream& stream) {
for (RuleMap::const_iterator it = rule_map.begin();
it != rule_map.end(); ++it) {
if (it != rule_map.begin())
@@ -261,7 +261,7 @@
return false;
}
-bool Module::Write(std::ostream &stream, SymbolData symbol_data) {
+bool Module::Write(std::ostream& stream, SymbolData symbol_data) {
stream << "MODULE " << os_ << " " << architecture_ << " "
<< id_ << " " << name_ << "\n";
if (!stream.good())
@@ -277,7 +277,7 @@
// Write out files.
for (FileByNameMap::iterator file_it = files_.begin();
file_it != files_.end(); ++file_it) {
- File *file = file_it->second;
+ File* file = file_it->second;
if (file->source_id >= 0) {
stream << "FILE " << file->source_id << " " << file->name << "\n";
if (!stream.good())
@@ -288,7 +288,7 @@
// Write out functions and their lines.
for (FunctionSet::const_iterator func_it = functions_.begin();
func_it != functions_.end(); ++func_it) {
- Function *func = *func_it;
+ Function* func = *func_it;
vector<Line>::iterator line_it = func->lines.begin();
for (auto range_it = func->ranges.cbegin();
range_it != func->ranges.cend(); ++range_it) {
@@ -322,7 +322,7 @@
// Write out 'PUBLIC' records.
for (ExternSet::const_iterator extern_it = externs_.begin();
extern_it != externs_.end(); ++extern_it) {
- Extern *ext = *extern_it;
+ Extern* ext = *extern_it;
stream << "PUBLIC " << hex
<< (ext->address - load_address_) << " 0 "
<< ext->name << dec << "\n";
@@ -331,10 +331,10 @@
if (symbol_data != NO_CFI) {
// Write out 'STACK CFI INIT' and 'STACK CFI' records.
- vector<StackFrameEntry *>::const_iterator frame_it;
+ vector<StackFrameEntry*>::const_iterator frame_it;
for (frame_it = stack_frame_entries_.begin();
frame_it != stack_frame_entries_.end(); ++frame_it) {
- StackFrameEntry *entry = *frame_it;
+ StackFrameEntry* entry = *frame_it;
stream << "STACK CFI INIT " << hex
<< (entry->address - load_address_) << " "
<< entry->size << " " << dec;
diff --git a/src/common/module.h b/src/common/module.h
index 7309ced..60bf709 100644
--- a/src/common/module.h
+++ b/src/common/module.h
@@ -74,7 +74,7 @@
// A source file.
struct File {
- explicit File(const string &name_input) : name(name_input), source_id(0) {}
+ explicit File(const string& name_input) : name(name_input), source_id(0) {}
// The name of the source file.
const string name;
@@ -96,12 +96,12 @@
// A function.
struct Function {
- Function(const string &name_input, const Address &address_input) :
+ Function(const string& name_input, const Address& address_input) :
name(name_input), address(address_input), parameter_size(0) {}
// For sorting by address. (Not style-guide compliant, but it's
// stupid not to put this in the struct.)
- static bool CompareByAddress(const Function *x, const Function *y) {
+ static bool CompareByAddress(const Function* x, const Function* y) {
return x->address < y->address;
}
@@ -124,18 +124,18 @@
struct Line {
// For sorting by address. (Not style-guide compliant, but it's
// stupid not to put this in the struct.)
- static bool CompareByAddress(const Module::Line &x, const Module::Line &y) {
+ static bool CompareByAddress(const Module::Line& x, const Module::Line& y) {
return x.address < y.address;
}
Address address, size; // The address and size of the line's code.
- File *file; // The source file.
+ File* file; // The source file.
int number; // The source line number.
};
// An exported symbol.
struct Extern {
- explicit Extern(const Address &address_input) : address(address_input) {}
+ explicit Extern(const Address& address_input) : address(address_input) {}
const Address address;
string name;
};
@@ -170,8 +170,7 @@
};
struct FunctionCompare {
- bool operator() (const Function *lhs,
- const Function *rhs) const {
+ bool operator() (const Function* lhs, const Function* rhs) const {
if (lhs->address == rhs->address)
return lhs->name < rhs->name;
return lhs->address < rhs->address;
@@ -179,16 +178,15 @@
};
struct ExternCompare {
- bool operator() (const Extern *lhs,
- const Extern *rhs) const {
+ bool operator() (const Extern* lhs, const Extern* rhs) const {
return lhs->address < rhs->address;
}
};
// Create a new module with the given name, operating system,
// architecture, and ID string.
- Module(const string &name, const string &os, const string &architecture,
- const string &id, const string &code_id = "");
+ Module(const string& name, const string& os, const string& architecture,
+ const string& id, const string& code_id = "");
~Module();
// Set the module's load address to LOAD_ADDRESS; addresses given
@@ -216,62 +214,62 @@
// Add FUNCTION to the module. FUNCTION's name must not be empty.
// This module owns all Function objects added with this function:
// destroying the module destroys them as well.
- void AddFunction(Function *function);
+ void AddFunction(Function* function);
// Add all the functions in [BEGIN,END) to the module.
// This module owns all Function objects added with this function:
// destroying the module destroys them as well.
- void AddFunctions(vector<Function *>::iterator begin,
- vector<Function *>::iterator end);
+ void AddFunctions(vector<Function*>::iterator begin,
+ vector<Function*>::iterator end);
// Add STACK_FRAME_ENTRY to the module.
// This module owns all StackFrameEntry objects added with this
// function: destroying the module destroys them as well.
- void AddStackFrameEntry(StackFrameEntry *stack_frame_entry);
+ void AddStackFrameEntry(StackFrameEntry* stack_frame_entry);
// Add PUBLIC to the module.
// This module owns all Extern objects added with this function:
// destroying the module destroys them as well.
- void AddExtern(Extern *ext);
+ void AddExtern(Extern* ext);
// If this module has a file named NAME, return a pointer to it. If
// it has none, then create one and return a pointer to the new
// file. This module owns all File objects created using these
// functions; destroying the module destroys them as well.
- File *FindFile(const string &name);
- File *FindFile(const char *name);
+ File* FindFile(const string& name);
+ File* FindFile(const char* name);
// If this module has a file named NAME, return a pointer to it.
// Otherwise, return NULL.
- File *FindExistingFile(const string &name);
+ File* FindExistingFile(const string& name);
// Insert pointers to the functions added to this module at I in
// VEC. The pointed-to Functions are still owned by this module.
// (Since this is effectively a copy of the function list, this is
// mostly useful for testing; other uses should probably get a more
// appropriate interface.)
- void GetFunctions(vector<Function *> *vec, vector<Function *>::iterator i);
+ void GetFunctions(vector<Function*>* vec, vector<Function*>::iterator i);
// Insert pointers to the externs added to this module at I in
// VEC. The pointed-to Externs are still owned by this module.
// (Since this is effectively a copy of the extern list, this is
// mostly useful for testing; other uses should probably get a more
// appropriate interface.)
- void GetExterns(vector<Extern *> *vec, vector<Extern *>::iterator i);
+ void GetExterns(vector<Extern*>* vec, vector<Extern*>::iterator i);
// Clear VEC and fill it with pointers to the Files added to this
// module, sorted by name. The pointed-to Files are still owned by
// this module. (Since this is effectively a copy of the file list,
// this is mostly useful for testing; other uses should probably get
// a more appropriate interface.)
- void GetFiles(vector<File *> *vec);
+ void GetFiles(vector<File*>* vec);
// Clear VEC and fill it with pointers to the StackFrameEntry
// objects that have been added to this module. (Since this is
// effectively a copy of the stack frame entry list, this is mostly
// useful for testing; other uses should probably get
// a more appropriate interface.)
- void GetStackFrameEntries(vector<StackFrameEntry *> *vec) const;
+ void GetStackFrameEntries(vector<StackFrameEntry*>* vec) const;
// Find those files in this module that are actually referred to by
// functions' line number data, and assign them source id numbers.
@@ -292,7 +290,7 @@
// - all CFI records.
// Addresses in the output are all relative to the load address
// established by SetLoadAddress.
- bool Write(std::ostream &stream, SymbolData symbol_data);
+ bool Write(std::ostream& stream, SymbolData symbol_data);
string name() const { return name_; }
string os() const { return os_; }
@@ -308,7 +306,7 @@
// Write RULE_MAP to STREAM, in the form appropriate for 'STACK CFI'
// records, without a final newline. Return true if all goes well;
// if an error occurs, return false, and leave errno set.
- static bool WriteRuleMap(const RuleMap &rule_map, std::ostream &stream);
+ static bool WriteRuleMap(const RuleMap& rule_map, std::ostream& stream);
// Returns true of the specified address resides with an specified address
// range, or if no ranges have been specified.
@@ -329,18 +327,18 @@
// Relation for maps whose keys are strings shared with some other
// structure.
struct CompareStringPtrs {
- bool operator()(const string *x, const string *y) const { return *x < *y; }
+ bool operator()(const string* x, const string* y) const { return *x < *y; }
};
// A map from filenames to File structures. The map's keys are
// pointers to the Files' names.
- typedef map<const string *, File *, CompareStringPtrs> FileByNameMap;
+ typedef map<const string*, File*, CompareStringPtrs> FileByNameMap;
// A set containing Function structures, sorted by address.
- typedef set<Function *, FunctionCompare> FunctionSet;
+ typedef set<Function*, FunctionCompare> FunctionSet;
// A set containing Extern structures, sorted by address.
- typedef set<Extern *, ExternCompare> ExternSet;
+ typedef set<Extern*, ExternCompare> ExternSet;
// The module owns all the files and functions that have been added
// to it; destroying the module frees the Files and Functions these
@@ -350,7 +348,7 @@
// The module owns all the call frame info entries that have been
// added to it.
- vector<StackFrameEntry *> stack_frame_entries_;
+ vector<StackFrameEntry*> stack_frame_entries_;
// The module owns all the externs that have been added to it;
// destroying the module frees the Externs these point to.
diff --git a/src/common/module_unittest.cc b/src/common/module_unittest.cc
index 37fee5d..cede09c 100644
--- a/src/common/module_unittest.cc
+++ b/src/common/module_unittest.cc
@@ -49,7 +49,7 @@
using std::vector;
using testing::ContainerEq;
-static Module::Function* generate_duplicate_function(const string &name) {
+static Module::Function* generate_duplicate_function(const string& name) {
const Module::Address DUP_ADDRESS = 0xd35402aac7a7ad5cULL;
const Module::Address DUP_SIZE = 0x200b26e605f99071ULL;
const Module::Address DUP_PARAMETER_SIZE = 0xf14ac4fed48c4a99ULL;
diff --git a/src/common/solaris/dump_symbols.cc b/src/common/solaris/dump_symbols.cc
index 168d0b2..9524a18 100644
--- a/src/common/solaris/dump_symbols.cc
+++ b/src/common/solaris/dump_symbols.cc
@@ -97,7 +97,7 @@
// Information of a function.
struct FuncInfo {
// Name of the function.
- const char *name;
+ const char* name;
// Offset from the base of the loading address.
GElf_Off rva_to_base;
// Virtual address of the function.
@@ -115,7 +115,7 @@
// Information of a source file.
struct SourceFileInfo {
// Name of the source file.
- const char *name;
+ const char* name;
// Starting address of the source file.
GElf_Addr addr;
// Id of the source file.
@@ -125,12 +125,12 @@
};
struct CompareString {
- bool operator()(const char *s1, const char *s2) const {
+ bool operator()(const char* s1, const char* s2) const {
return strcmp(s1, s2) < 0;
}
};
-typedef std::map<const char *, struct SymbolEntry *, CompareString> SymbolMap;
+typedef std::map<const char*, struct SymbolEntry*, CompareString> SymbolMap;
// Information of a symbol table.
// This is the root of all types of symbol.
@@ -141,16 +141,16 @@
};
// Stab section name.
-const char *kStabName = ".stab";
+const char* kStabName = ".stab";
// Stab str section name.
-const char *kStabStrName = ".stabstr";
+const char* kStabStrName = ".stabstr";
// Symtab section name.
-const char *kSymtabName = ".symtab";
+const char* kSymtabName = ".symtab";
// Strtab section name.
-const char *kStrtabName = ".strtab";
+const char* kStrtabName = ".strtab";
// Default buffer lenght for demangle.
const int demangleLen = 20000;
@@ -160,11 +160,11 @@
// Update the offset to the start of the string index of the next
// object module for every N_ENDM stabs.
-inline void RecalculateOffset(struct slist* cur_list, char *stabstr) {
+inline void RecalculateOffset(struct slist* cur_list, char* stabstr) {
while ((--cur_list)->n_strx == 0) ;
stringOffset += cur_list->n_strx;
- char *temp = stabstr + stringOffset;
+ char* temp = stabstr + stringOffset;
while (*temp != '\0') {
++stringOffset;
++temp;
@@ -174,10 +174,10 @@
}
// Demangle using demangle library on Solaris.
-std::string Demangle(const char *mangled) {
+std::string Demangle(const char* mangled) {
int status = 0;
std::string str(mangled);
- char *demangled = (char *)malloc(demangleLen);
+ char* demangled = (char*)malloc(demangleLen);
if (!demangled) {
fprintf(stderr, "no enough memory.\n");
@@ -197,7 +197,7 @@
return str;
}
-bool WriteFormat(int fd, const char *fmt, ...) {
+bool WriteFormat(int fd, const char* fmt, ...) {
va_list list;
char buffer[4096];
ssize_t expected, written;
@@ -209,27 +209,27 @@
return expected == written;
}
-bool IsValidElf(const GElf_Ehdr *elf_header) {
+bool IsValidElf(const GElf_Ehdr* elf_header) {
return memcmp(elf_header, ELFMAG, SELFMAG) == 0;
}
-static bool FindSectionByName(Elf *elf, const char *name,
+static bool FindSectionByName(Elf* elf, const char* name,
int shstrndx,
- GElf_Shdr *shdr) {
+ GElf_Shdr* shdr) {
assert(name != NULL);
if (strlen(name) == 0)
return false;
- Elf_Scn *scn = NULL;
+ Elf_Scn* scn = NULL;
while ((scn = elf_nextscn(elf, scn)) != NULL) {
- if (gelf_getshdr(scn, shdr) == (GElf_Shdr *)0) {
+ if (gelf_getshdr(scn, shdr) == (GElf_Shdr*)0) {
fprintf(stderr, "failed to read section header: %s\n", elf_errmsg(0));
return false;
}
- const char *section_name = elf_strptr(elf, shstrndx, shdr->sh_name);
+ const char* section_name = elf_strptr(elf, shstrndx, shdr->sh_name);
if (!section_name) {
fprintf(stderr, "Section name error: %s\n", elf_errmsg(-1));
continue;
@@ -245,10 +245,10 @@
// The parameter size is used for FPO-optimized code, and
// this is all tied up with the debugging data for Windows x86.
// Set it to 0 on Solaris.
-int LoadStackParamSize(struct slist *list,
- struct slist *list_end,
- struct FuncInfo *func_info) {
- struct slist *cur_list = list;
+int LoadStackParamSize(struct slist* list,
+ struct slist* list_end,
+ struct FuncInfo* func_info) {
+ struct slist* cur_list = list;
int step = 1;
while (cur_list < list_end && cur_list->n_type == N_PSYM) {
++cur_list;
@@ -259,10 +259,10 @@
return step;
}
-int LoadLineInfo(struct slist *list,
- struct slist *list_end,
- struct FuncInfo *func_info) {
- struct slist *cur_list = list;
+int LoadLineInfo(struct slist* list,
+ struct slist* list_end,
+ struct FuncInfo* func_info) {
+ struct slist* cur_list = list;
do {
// Skip non line information.
while (cur_list < list_end && cur_list->n_type != N_SLINE) {
@@ -288,12 +288,12 @@
return cur_list - list;
}
-int LoadFuncSymbols(struct slist *list,
- struct slist *list_end,
- char *stabstr,
+int LoadFuncSymbols(struct slist* list,
+ struct slist* list_end,
+ char* stabstr,
GElf_Word base,
- struct SourceFileInfo *source_file_info) {
- struct slist *cur_list = list;
+ struct SourceFileInfo* source_file_info) {
+ struct slist* cur_list = list;
assert(cur_list->n_type == N_SO);
++cur_list;
@@ -342,17 +342,17 @@
}
// Compute size and rva information based on symbols loaded from stab section.
-bool ComputeSizeAndRVA(struct SymbolInfo *symbols) {
- std::vector<struct SourceFileInfo> *sorted_files =
+bool ComputeSizeAndRVA(struct SymbolInfo* symbols) {
+ std::vector<struct SourceFileInfo>* sorted_files =
&(symbols->source_file_info);
- SymbolMap *symbol_entries = &(symbols->symbol_entries);
+ SymbolMap* symbol_entries = &(symbols->symbol_entries);
for (size_t i = 0; i < sorted_files->size(); ++i) {
- struct SourceFileInfo &source_file = (*sorted_files)[i];
- std::vector<struct FuncInfo> *sorted_functions = &(source_file.func_info);
+ struct SourceFileInfo& source_file = (*sorted_files)[i];
+ std::vector<struct FuncInfo>* sorted_functions = &(source_file.func_info);
int func_size = sorted_functions->size();
for (size_t j = 0; j < func_size; ++j) {
- struct FuncInfo &func_info = (*sorted_functions)[j];
+ struct FuncInfo& func_info = (*sorted_functions)[j];
int line_count = func_info.line_info.size();
// Discard the ending part of the name.
@@ -373,13 +373,13 @@
// Compute function and line size.
for (size_t k = 0; k < line_count; ++k) {
- struct LineInfo &line_info = func_info.line_info[k];
+ struct LineInfo& line_info = func_info.line_info[k];
line_info.rva_to_base = line_info.rva_to_func + func_info.rva_to_base;
if (k == line_count - 1) {
line_info.size = func_info.size - line_info.rva_to_func;
} else {
- struct LineInfo &next_line = func_info.line_info[k + 1];
+ struct LineInfo& next_line = func_info.line_info[k + 1];
line_info.size = next_line.rva_to_func - line_info.rva_to_func;
}
} // for each line.
@@ -392,24 +392,23 @@
return true;
}
-bool LoadAllSymbols(const GElf_Shdr *stab_section,
- const GElf_Shdr *stabstr_section,
+bool LoadAllSymbols(const GElf_Shdr* stab_section,
+ const GElf_Shdr* stabstr_section,
GElf_Word base,
- struct SymbolInfo *symbols) {
+ struct SymbolInfo* symbols) {
if (stab_section == NULL || stabstr_section == NULL)
return false;
- char *stabstr =
- reinterpret_cast<char *>(stabstr_section->sh_offset + base);
- struct slist *lists =
- reinterpret_cast<struct slist *>(stab_section->sh_offset + base);
+ char* stabstr = reinterpret_cast<char*>(stabstr_section->sh_offset + base);
+ struct slist* lists =
+ reinterpret_cast<struct slist*>(stab_section->sh_offset + base);
int nstab = stab_section->sh_size / sizeof(struct slist);
int source_id = 0;
// First pass, load all symbols from the object file.
for (int i = 0; i < nstab; ) {
int step = 1;
- struct slist *cur_list = lists + i;
+ struct slist* cur_list = lists + i;
if (cur_list->n_type == N_SO) {
// FUNC <address> <size> <param_stack_size> <function>
struct SourceFileInfo source_file_info;
@@ -431,12 +430,12 @@
return ComputeSizeAndRVA(symbols);
}
-bool LoadSymbols(Elf *elf, GElf_Ehdr *elf_header, struct SymbolInfo *symbols,
- void *obj_base) {
+bool LoadSymbols(Elf* elf, GElf_Ehdr* elf_header, struct SymbolInfo* symbols,
+ void* obj_base) {
GElf_Word base = reinterpret_cast<GElf_Word>(obj_base);
- const GElf_Shdr *sections =
- reinterpret_cast<GElf_Shdr *>(elf_header->e_shoff + base);
+ const GElf_Shdr* sections =
+ reinterpret_cast<GElf_Shdr*>(elf_header->e_shoff + base);
GElf_Shdr stab_section;
if (!FindSectionByName(elf, kStabName, elf_header->e_shstrndx,
&stab_section)) {
@@ -462,11 +461,11 @@
return false;
}
- Elf_Sym *symbol = (Elf_Sym *)((char *)base + symtab_section.sh_offset);
+ Elf_Sym* symbol = (Elf_Sym*)((char*)base + symtab_section.sh_offset);
for (int i = 0; i < symtab_section.sh_size/symtab_section.sh_entsize; ++i) {
- struct SymbolEntry *symbol_entry =
- (struct SymbolEntry *)malloc(sizeof(struct SymbolEntry));
- const char *name = reinterpret_cast<char *>(
+ struct SymbolEntry* symbol_entry =
+ (struct SymbolEntry*)malloc(sizeof(struct SymbolEntry));
+ const char* name = reinterpret_cast<char*>(
strtab_section.sh_offset + (GElf_Word)base + symbol->st_name);
symbol_entry->offset = symbol->st_value;
symbol_entry->size = symbol->st_size;
@@ -479,8 +478,8 @@
return LoadAllSymbols(&stab_section, &stabstr_section, base, symbols);
}
-bool WriteModuleInfo(int fd, GElf_Half arch, const std::string &obj_file) {
- const char *arch_name = NULL;
+bool WriteModuleInfo(int fd, GElf_Half arch, const std::string& obj_file) {
+ const char* arch_name = NULL;
if (arch == EM_386)
arch_name = "x86";
else if (arch == EM_X86_64)
@@ -508,10 +507,10 @@
return false;
}
-bool WriteSourceFileInfo(int fd, const struct SymbolInfo &symbols) {
+bool WriteSourceFileInfo(int fd, const struct SymbolInfo& symbols) {
for (size_t i = 0; i < symbols.source_file_info.size(); ++i) {
if (symbols.source_file_info[i].source_id != -1) {
- const char *name = symbols.source_file_info[i].name;
+ const char* name = symbols.source_file_info[i].name;
if (!WriteFormat(fd, "FILE %d %s\n",
symbols.source_file_info[i].source_id, name))
return false;
@@ -521,7 +520,7 @@
}
bool WriteOneFunction(int fd, int source_id,
- const struct FuncInfo &func_info){
+ const struct FuncInfo& func_info){
// Discard the ending part of the name.
std::string func_name(func_info.name);
std::string::size_type last_colon = func_name.find_last_of(':');
@@ -539,7 +538,7 @@
func_info.stack_param_size,
func_name.c_str())) {
for (size_t i = 0; i < func_info.line_info.size(); ++i) {
- const struct LineInfo &line_info = func_info.line_info[i];
+ const struct LineInfo& line_info = func_info.line_info[i];
if (line_info.line_num == 0)
return true;
if (!WriteFormat(fd, "%llx %x %d %d\n",
@@ -554,11 +553,11 @@
return false;
}
-bool WriteFunctionInfo(int fd, const struct SymbolInfo &symbols) {
+bool WriteFunctionInfo(int fd, const struct SymbolInfo& symbols) {
for (size_t i = 0; i < symbols.source_file_info.size(); ++i) {
- const struct SourceFileInfo &file_info = symbols.source_file_info[i];
+ const struct SourceFileInfo& file_info = symbols.source_file_info[i];
for (size_t j = 0; j < file_info.func_info.size(); ++j) {
- const struct FuncInfo &func_info = file_info.func_info[j];
+ const struct FuncInfo& func_info = file_info.func_info[j];
if (!WriteOneFunction(fd, file_info.source_id, func_info))
return false;
}
@@ -566,7 +565,7 @@
return true;
}
-bool DumpStabSymbols(int fd, const struct SymbolInfo &symbols) {
+bool DumpStabSymbols(int fd, const struct SymbolInfo& symbols) {
return WriteSourceFileInfo(fd, symbols) &&
WriteFunctionInfo(fd, symbols);
}
@@ -604,13 +603,13 @@
//
class MmapWrapper {
public:
- MmapWrapper(void *mapped_address, size_t mapped_size) :
+ MmapWrapper(void* mapped_address, size_t mapped_size) :
base_(mapped_address), size_(mapped_size) {
}
~MmapWrapper() {
if (base_ != NULL) {
assert(size_ > 0);
- munmap((char *)base_, size_);
+ munmap((char*)base_, size_);
}
}
void release() {
@@ -619,7 +618,7 @@
}
private:
- void *base_;
+ void* base_;
size_t size_;
};
@@ -629,14 +628,14 @@
class AutoElfEnder {
public:
- AutoElfEnder(Elf *elf) : elf_(elf) {}
+ AutoElfEnder(Elf* elf) : elf_(elf) {}
~AutoElfEnder() { if (elf_) elf_end(elf_); }
private:
- Elf *elf_;
+ Elf* elf_;
};
-bool DumpSymbols::WriteSymbolFile(const std::string &obj_file, int sym_fd) {
+bool DumpSymbols::WriteSymbolFile(const std::string& obj_file, int sym_fd) {
if (elf_version(EV_CURRENT) == EV_NONE) {
fprintf(stderr, "elf_version() failed: %s\n", elf_errmsg(0));
return false;
@@ -649,16 +648,16 @@
struct stat st;
if (fstat(obj_fd, &st) != 0 && st.st_size <= 0)
return false;
- void *obj_base = mmap(NULL, st.st_size,
+ void* obj_base = mmap(NULL, st.st_size,
PROT_READ, MAP_PRIVATE, obj_fd, 0);
if (obj_base == MAP_FAILED)
return false;
MmapWrapper map_wrapper(obj_base, st.st_size);
GElf_Ehdr elf_header;
- Elf *elf = elf_begin(obj_fd, ELF_C_READ, NULL);
+ Elf* elf = elf_begin(obj_fd, ELF_C_READ, NULL);
AutoElfEnder elfEnder(elf);
- if (gelf_getehdr(elf, &elf_header) == (GElf_Ehdr *)NULL) {
+ if (gelf_getehdr(elf, &elf_header) == (GElf_Ehdr*)NULL) {
fprintf(stderr, "failed to read elf header: %s\n", elf_errmsg(-1));
return false;
}
diff --git a/src/common/solaris/dump_symbols.h b/src/common/solaris/dump_symbols.h
index 7f4baad..3bca8a2 100644
--- a/src/common/solaris/dump_symbols.h
+++ b/src/common/solaris/dump_symbols.h
@@ -40,7 +40,7 @@
class DumpSymbols {
public:
- bool WriteSymbolFile(const std::string &obj_file,
+ bool WriteSymbolFile(const std::string& obj_file,
int sym_fd);
};
diff --git a/src/common/solaris/file_id.cc b/src/common/solaris/file_id.cc
index 643a146..c32c73b 100644
--- a/src/common/solaris/file_id.cc
+++ b/src/common/solaris/file_id.cc
@@ -54,17 +54,17 @@
class AutoElfEnder {
public:
- AutoElfEnder(Elf *elf) : elf_(elf) {}
+ AutoElfEnder(Elf* elf) : elf_(elf) {}
~AutoElfEnder() { if (elf_) elf_end(elf_); }
private:
- Elf *elf_;
+ Elf* elf_;
};
// Find the text section in elf object file.
// Return the section start address and the size.
-static bool FindElfTextSection(int fd, const void *elf_base,
- const void **text_start,
- int *text_size) {
+static bool FindElfTextSection(int fd, const void* elf_base,
+ const void** text_start,
+ int* text_size) {
assert(text_start);
assert(text_size);
@@ -78,10 +78,10 @@
GElf_Ehdr elf_header;
lseek(fd, 0L, 0);
- Elf *elf = elf_begin(fd, ELF_C_READ, NULL);
+ Elf* elf = elf_begin(fd, ELF_C_READ, NULL);
AutoElfEnder elfEnder(elf);
- if (gelf_getehdr(elf, &elf_header) == (GElf_Ehdr *)NULL) {
+ if (gelf_getehdr(elf, &elf_header) == (GElf_Ehdr*)NULL) {
print_message2(2, "failed to read elf header: %s\n", elf_errmsg(-1));
return false;
}
@@ -95,18 +95,18 @@
}
static const char kTextSectionName[] = ".text";
- const GElf_Shdr *text_section = NULL;
- Elf_Scn *scn = NULL;
+ const GElf_Shdr* text_section = NULL;
+ Elf_Scn* scn = NULL;
GElf_Shdr shdr;
while ((scn = elf_nextscn(elf, scn)) != NULL) {
- if (gelf_getshdr(scn, &shdr) == (GElf_Shdr *)0) {
+ if (gelf_getshdr(scn, &shdr) == (GElf_Shdr*)0) {
print_message2(2, "failed to read section header: %s\n", elf_errmsg(0));
return false;
}
if (shdr.sh_type == SHT_PROGBITS) {
- const char *section_name = elf_strptr(elf, elf_header.e_shstrndx,
+ const char* section_name = elf_strptr(elf, elf_header.e_shstrndx,
shdr.sh_name);
if (!section_name) {
print_message2(2, "Section name error: %s\n", elf_errmsg(-1));
@@ -120,7 +120,7 @@
}
}
if (text_section != NULL && text_section->sh_size > 0) {
- *text_start = (char *)elf_base + text_section->sh_offset;
+ *text_start = (char*)elf_base + text_section->sh_offset;
*text_size = text_section->sh_size;
return true;
}
@@ -128,7 +128,7 @@
return false;
}
-FileID::FileID(const char *path) {
+FileID::FileID(const char* path) {
strcpy(path_, path);
}
@@ -150,29 +150,29 @@
if (fstat(fd, &st) != 0 || st.st_size <= 0)
return false;
- void *base = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
+ void* base = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (base == MAP_FAILED)
return false;
bool success = false;
- const void *text_section = NULL;
+ const void* text_section = NULL;
int text_size = 0;
if (FindElfTextSection(fd, base, &text_section, &text_size)) {
MD5Context md5;
MD5Init(&md5);
- MD5Update(&md5, (const unsigned char *)text_section, text_size);
+ MD5Update(&md5, (const unsigned char*)text_section, text_size);
MD5Final(identifier, &md5);
success = true;
}
- munmap((char *)base, st.st_size);
+ munmap((char*)base, st.st_size);
return success;
}
// static
bool FileID::ConvertIdentifierToString(const unsigned char identifier[16],
- char *buffer, int buffer_length) {
+ char* buffer, int buffer_length) {
if (buffer_length < 34)
return false;
diff --git a/src/common/solaris/guid_creator.cc b/src/common/solaris/guid_creator.cc
index e9e6c6f..17d773e 100644
--- a/src/common/solaris/guid_creator.cc
+++ b/src/common/solaris/guid_creator.cc
@@ -74,8 +74,8 @@
assert(buf_len > kGUIDStringLength);
int num = snprintf(buf, buf_len, kGUIDFormatString,
guid->data1, guid->data2, guid->data3,
- *reinterpret_cast<const uint32_t *>(&(guid->data4[0])),
- *reinterpret_cast<const uint32_t *>(&(guid->data4[4])));
+ *reinterpret_cast<const uint32_t*>(&(guid->data4[0])),
+ *reinterpret_cast<const uint32_t*>(&(guid->data4[4])));
if (num != kGUIDStringLength)
return false;
diff --git a/src/common/stabs_reader.cc b/src/common/stabs_reader.cc
index 6019fc7..43c4040 100644
--- a/src/common/stabs_reader.cc
+++ b/src/common/stabs_reader.cc
@@ -45,7 +45,7 @@
namespace google_breakpad {
-StabsReader::EntryIterator::EntryIterator(const ByteBuffer *buffer,
+StabsReader::EntryIterator::EntryIterator(const ByteBuffer* buffer,
bool big_endian, size_t value_size)
: value_size_(value_size), cursor_(buffer, big_endian) {
// Actually, we could handle weird sizes just fine, but they're
@@ -65,10 +65,10 @@
entry_.at_end = !cursor_;
}
-StabsReader::StabsReader(const uint8_t *stab, size_t stab_size,
- const uint8_t *stabstr, size_t stabstr_size,
+StabsReader::StabsReader(const uint8_t* stab, size_t stab_size,
+ const uint8_t* stabstr, size_t stabstr_size,
bool big_endian, size_t value_size, bool unitized,
- StabsHandler *handler)
+ StabsHandler* handler)
: entries_(stab, stab_size),
strings_(stabstr, stabstr_size),
iterator_(&entries_, big_endian, value_size),
@@ -78,7 +78,7 @@
next_cu_string_offset_(0),
current_source_file_(NULL) { }
-const char *StabsReader::SymbolString() {
+const char* StabsReader::SymbolString() {
ptrdiff_t offset = string_offset_ + iterator_->name_offset;
if (offset < 0 || (size_t) offset >= strings_.Size()) {
handler_->Warning("symbol %d: name offset outside the string section\n",
@@ -87,7 +87,7 @@
// taken from the string section.
offset = 0;
}
- return reinterpret_cast<const char *>(strings_.start + offset);
+ return reinterpret_cast<const char*>(strings_.start + offset);
}
bool StabsReader::Process() {
@@ -134,9 +134,9 @@
// There may be an N_SO entry whose name ends with a slash,
// indicating the directory in which the compilation occurred.
// The build directory defaults to NULL.
- const char *build_directory = NULL;
+ const char* build_directory = NULL;
{
- const char *name = SymbolString();
+ const char* name = SymbolString();
if (name[0] && name[strlen(name) - 1] == '/') {
build_directory = name;
++iterator_;
@@ -148,7 +148,7 @@
{
if (iterator_->at_end || iterator_->type != N_SO)
return true;
- const char *name = SymbolString();
+ const char* name = SymbolString();
if (name[0] == '\0') {
// This seems to be a stray end-of-compilation-unit marker;
// consume it, but don't report the end, since we didn't see a
@@ -203,7 +203,7 @@
uint64_t ending_address = 0;
if (!iterator_->at_end) {
assert(iterator_->type == N_SO);
- const char *name = SymbolString();
+ const char* name = SymbolString();
if (name[0] == '\0') {
ending_address = iterator_->value;
++iterator_;
@@ -225,8 +225,8 @@
// The STABS string for an N_FUN entry is the name of the function,
// followed by a colon, followed by type information for the
// function. We want to pass the name alone to StartFunction.
- const char *stab_string = SymbolString();
- const char *name_end = strchr(stab_string, ':');
+ const char* stab_string = SymbolString();
+ const char* name_end = strchr(stab_string, ':');
if (! name_end)
name_end = stab_string + strlen(stab_string);
string name(stab_string, name_end - stab_string);
@@ -270,7 +270,7 @@
if (!iterator_->at_end) {
assert(iterator_->type == N_SO || iterator_->type == N_FUN);
if (iterator_->type == N_FUN) {
- const char *symbol_name = SymbolString();
+ const char* symbol_name = SymbolString();
if (symbol_name[0] == '\0') {
// An N_FUN entry with no name is a terminator for this function;
// its value is the function's size.
diff --git a/src/common/stabs_reader.h b/src/common/stabs_reader.h
index 98ee2dd..1e773f4 100644
--- a/src/common/stabs_reader.h
+++ b/src/common/stabs_reader.h
@@ -92,10 +92,10 @@
//
// Note that, in ELF, the .stabstr section should be found using the
// 'sh_link' field of the .stab section header, not by name.
- StabsReader(const uint8_t *stab, size_t stab_size,
- const uint8_t *stabstr, size_t stabstr_size,
+ StabsReader(const uint8_t* stab, size_t stab_size,
+ const uint8_t* stabstr, size_t stabstr_size,
bool big_endian, size_t value_size, bool unitized,
- StabsHandler *handler);
+ StabsHandler* handler);
// Process the STABS data, calling the handler's member functions to
// report what we find. While the handler functions return true,
@@ -149,17 +149,17 @@
// Mac, they are 32 or 64 bits long. Oddly, the section header's entry
// size for a Linux ELF .stab section varies according to the ELF class
// from 12 to 20 even as the actual entries remain unchanged.
- EntryIterator(const ByteBuffer *buffer, bool big_endian, size_t value_size);
+ EntryIterator(const ByteBuffer* buffer, bool big_endian, size_t value_size);
// Move to the next entry. This function's behavior is undefined if
// at_end() is true when it is called.
- EntryIterator &operator++() { Fetch(); entry_.index++; return *this; }
+ EntryIterator& operator++() { Fetch(); entry_.index++; return *this; }
// Dereferencing this iterator produces a reference to an Entry structure
// that holds the current entry's values. The entry is owned by this
// EntryIterator, and will be invalidated at the next call to operator++.
- const Entry &operator*() const { return entry_; }
- const Entry *operator->() const { return &entry_; }
+ const Entry& operator*() const { return entry_; }
+ const Entry* operator->() const { return &entry_; }
private:
// Read the STABS entry at cursor_, and set entry_ appropriately.
@@ -178,12 +178,12 @@
// A source line, saved to be reported later.
struct Line {
uint64_t address;
- const char *filename;
+ const char* filename;
int number;
};
// Return the name of the current symbol.
- const char *SymbolString();
+ const char* SymbolString();
// Process a compilation unit starting at symbol_. Return true
// to continue processing, or false to abort.
@@ -210,7 +210,7 @@
// StabsReader::StabsReader.
bool unitized_;
- StabsHandler *handler_;
+ StabsHandler* handler_;
// The offset of the current compilation unit's strings within stabstr_.
size_t string_offset_;
@@ -220,7 +220,7 @@
size_t next_cu_string_offset_;
// The current source file name.
- const char *current_source_file_;
+ const char* current_source_file_;
// Mac OS X STABS place SLINE records before functions; we accumulate a
// vector of these until we see the FUN record, and then report them
@@ -261,7 +261,7 @@
// FILENAME values are different addresses, they represent different
// file names.
//
- // Thus, it's safe to use (say) std::map<char *, ...>, which does
+ // Thus, it's safe to use (say) std::map<char*, ...>, which does
// string address comparisons, not string content comparisons.
// Since all the strings are in same array of characters --- the
// .stabstr section --- comparing their addresses produces
@@ -271,8 +271,8 @@
// named FILENAME, and whose base address is ADDRESS. If
// BUILD_DIRECTORY is non-NULL, it is the name of the build
// directory in which the compilation occurred.
- virtual bool StartCompilationUnit(const char *filename, uint64_t address,
- const char *build_directory) {
+ virtual bool StartCompilationUnit(const char* filename, uint64_t address,
+ const char* build_directory) {
return true;
}
@@ -292,7 +292,7 @@
// StartFunction is the function name alone.
//
// In languages that use name mangling, like C++, NAME is mangled.
- virtual bool StartFunction(const string &name, uint64_t address) {
+ virtual bool StartFunction(const string& name, uint64_t address) {
return true;
}
@@ -305,19 +305,19 @@
// Report that the code at ADDRESS is attributable to line NUMBER of
// the source file named FILENAME. The caller must infer the ending
// address of the line.
- virtual bool Line(uint64_t address, const char *filename, int number) {
+ virtual bool Line(uint64_t address, const char* filename, int number) {
return true;
}
// Report that an exported function NAME is present at ADDRESS.
// The size of the function is unknown.
- virtual bool Extern(const string &name, uint64_t address) {
+ virtual bool Extern(const string& name, uint64_t address) {
return true;
}
// Report a warning. FORMAT is a printf-like format string,
// specifying how to format the subsequent arguments.
- virtual void Warning(const char *format, ...) = 0;
+ virtual void Warning(const char* format, ...) = 0;
};
} // namespace google_breakpad
diff --git a/src/common/stabs_reader_unittest.cc b/src/common/stabs_reader_unittest.cc
index a84da1c..24f3e1a 100644
--- a/src/common/stabs_reader_unittest.cc
+++ b/src/common/stabs_reader_unittest.cc
@@ -75,7 +75,7 @@
// Add the string S to this StringAssembler, and return the string's
// offset within this compilation unit's strings. If S has been added
// already, this returns the offset of its first instance.
- size_t Add(const string &s) {
+ size_t Add(const string& s) {
map<string, size_t>::iterator it = added_.find(s);
if (it != added_.end())
return it->second;
@@ -127,7 +127,7 @@
class StabsAssembler: public Section {
public:
// Create a StabsAssembler that uses StringAssembler for its strings.
- StabsAssembler(StringAssembler *string_assembler)
+ StabsAssembler(StringAssembler* string_assembler)
: Section(string_assembler->endianness()),
string_assembler_(string_assembler),
value_size_(0),
@@ -137,7 +137,7 @@
// Accessor and setter for value_size_.
size_t value_size() const { return value_size_; }
- StabsAssembler &set_value_size(size_t value_size) {
+ StabsAssembler& set_value_size(size_t value_size) {
value_size_ = value_size;
return *this;
}
@@ -147,7 +147,7 @@
// its compilation unit's portion of the .stabstr section; this can be a
// value generated by a StringAssembler. Return a reference to this
// StabsAssembler.
- StabsAssembler &Stab(uint8_t type, uint8_t other, Label descriptor,
+ StabsAssembler& Stab(uint8_t type, uint8_t other, Label descriptor,
Label value, Label name) {
D32(name);
D8(type);
@@ -159,15 +159,15 @@
}
// As above, but automatically add NAME to our StringAssembler.
- StabsAssembler &Stab(uint8_t type, uint8_t other, Label descriptor,
- Label value, const string &name) {
+ StabsAssembler& Stab(uint8_t type, uint8_t other, Label descriptor,
+ Label value, const string& name) {
return Stab(type, other, descriptor, value, string_assembler_->Add(name));
}
// Start a compilation unit named NAME, with an N_UNDF symbol to start
// it, and its own portion of the string section. Return a reference to
// this StabsAssembler.
- StabsAssembler &StartCU(const string &name) {
+ StabsAssembler& StartCU(const string& name) {
assert(!cu_header_);
cu_header_ = new CUHeader;
string_assembler_->StartCU();
@@ -180,7 +180,7 @@
// Close off the current compilation unit. Return a reference to this
// StabsAssembler.
- StabsAssembler &EndCU() {
+ StabsAssembler& EndCU() {
assert(cu_header_);
cu_header_->final_entry_count = entry_count_;
cu_header_->final_string_size = string_assembler_->EndCU();
@@ -201,7 +201,7 @@
};
// The strings for our STABS entries.
- StringAssembler *string_assembler_;
+ StringAssembler* string_assembler_;
// The size of the 'value' field of stabs entries in this section.
size_t value_size_;
@@ -211,20 +211,20 @@
// Header labels for this compilation unit, if we've started one but not
// finished it.
- CUHeader *cu_header_;
+ CUHeader* cu_header_;
};
class MockStabsReaderHandler: public StabsHandler {
public:
MOCK_METHOD3(StartCompilationUnit,
- bool(const char *, uint64_t, const char *));
+ bool(const char*, uint64_t, const char*));
MOCK_METHOD1(EndCompilationUnit, bool(uint64_t));
- MOCK_METHOD2(StartFunction, bool(const string &, uint64_t));
+ MOCK_METHOD2(StartFunction, bool(const string&, uint64_t));
MOCK_METHOD1(EndFunction, bool(uint64_t));
- MOCK_METHOD3(Line, bool(uint64_t, const char *, int));
- MOCK_METHOD2(Extern, bool(const string &, uint64_t));
- void Warning(const char *format, ...) { MockWarning(format); }
- MOCK_METHOD1(MockWarning, void(const char *));
+ MOCK_METHOD3(Line, bool(uint64_t, const char*, int));
+ MOCK_METHOD2(Extern, bool(const string&, uint64_t));
+ void Warning(const char* format, ...) { MockWarning(format); }
+ MOCK_METHOD1(MockWarning, void(const char*));
};
struct StabsFixture {
@@ -243,9 +243,9 @@
// Run the parser on the test input, passing whatever we find to HANDLER.
StabsReader reader(
- reinterpret_cast<const uint8_t *>(stabs_contents.data()),
+ reinterpret_cast<const uint8_t*>(stabs_contents.data()),
stabs_contents.size(),
- reinterpret_cast<const uint8_t *>(stabstr_contents.data()),
+ reinterpret_cast<const uint8_t*>(stabstr_contents.data()),
stabstr_contents.size(),
stabs.endianness() == kBigEndian, stabs.value_size(), unitized,
&mock_handler);
diff --git a/src/common/stabs_to_module.cc b/src/common/stabs_to_module.cc
index 049a6cc..05b25a7 100644
--- a/src/common/stabs_to_module.cc
+++ b/src/common/stabs_to_module.cc
@@ -45,7 +45,7 @@
// Demangle using abi call.
// Older GCC may not support it.
-static string Demangle(const string &mangled) {
+static string Demangle(const string& mangled) {
int status = 0;
char *demangled = abi::__cxa_demangle(mangled.c_str(), NULL, NULL, &status);
if (status == 0 && demangled != NULL) {
@@ -58,7 +58,7 @@
StabsToModule::~StabsToModule() {
// Free any functions we've accumulated but not added to the module.
- for (vector<Module::Function *>::const_iterator func_it = functions_.begin();
+ for (vector<Module::Function*>::const_iterator func_it = functions_.begin();
func_it != functions_.end(); func_it++)
delete *func_it;
// Free any function that we're currently within.
@@ -87,7 +87,7 @@
return true;
}
-bool StabsToModule::StartFunction(const string &name,
+bool StabsToModule::StartFunction(const string& name,
uint64_t address) {
assert(!current_function_);
Module::Function *f = new Module::Function(Demangle(name), address);
@@ -131,7 +131,7 @@
return true;
}
-bool StabsToModule::Extern(const string &name, uint64_t address) {
+bool StabsToModule::Extern(const string& name, uint64_t address) {
Module::Extern *ext = new Module::Extern(address);
// Older libstdc++ demangle implementations can crash on unexpected
// input, so be careful about what gets passed in.
@@ -160,7 +160,7 @@
sort(functions_.begin(), functions_.end(),
Module::Function::CompareByAddress);
- for (vector<Module::Function *>::const_iterator func_it = functions_.begin();
+ for (vector<Module::Function*>::const_iterator func_it = functions_.begin();
func_it != functions_.end();
func_it++) {
Module::Function *f = *func_it;
diff --git a/src/common/stabs_to_module.h b/src/common/stabs_to_module.h
index 5e04fa7..6f6e0ed 100644
--- a/src/common/stabs_to_module.h
+++ b/src/common/stabs_to_module.h
@@ -76,10 +76,10 @@
bool StartCompilationUnit(const char *name, uint64_t address,
const char *build_directory);
bool EndCompilationUnit(uint64_t address);
- bool StartFunction(const string &name, uint64_t address);
+ bool StartFunction(const string& name, uint64_t address);
bool EndFunction(uint64_t address);
bool Line(uint64_t address, const char *name, int number);
- bool Extern(const string &name, uint64_t address);
+ bool Extern(const string& name, uint64_t address);
void Warning(const char *format, ...);
// Do any final processing necessary to make module_ contain all the
@@ -107,7 +107,7 @@
// We could just stick them in module_ from the outset, but if
// module_ already contains data gathered from other debugging
// formats, that would complicate the size computation.
- vector<Module::Function *> functions_;
+ vector<Module::Function*> functions_;
// Boundary addresses. STABS doesn't necessarily supply sizes for
// functions and lines, so we need to compute them ourselves by
diff --git a/src/common/stabs_to_module_unittest.cc b/src/common/stabs_to_module_unittest.cc
index aae0047..9c134e7 100644
--- a/src/common/stabs_to_module_unittest.cc
+++ b/src/common/stabs_to_module_unittest.cc
@@ -58,7 +58,7 @@
Module::File *file = m.FindExistingFile("source-file-name");
ASSERT_TRUE(file != NULL);
- vector<Module::Function *> functions;
+ vector<Module::Function*> functions;
m.GetFunctions(&functions, functions.end());
ASSERT_EQ((size_t) 1, functions.size());
Module::Function *function = functions[0];
@@ -88,7 +88,7 @@
h.Finalize();
// Now check to see what has been added to the Module.
- vector<Module::Extern *> externs;
+ vector<Module::Extern*> externs;
m.GetExterns(&externs, externs.end());
ASSERT_EQ((size_t) 3, externs.size());
Module::Extern *extern1 = externs[0];
@@ -124,7 +124,7 @@
Module::File *file = m.FindExistingFile("compilation-unit");
ASSERT_TRUE(file != NULL);
- vector<Module::Function *> functions;
+ vector<Module::Function*> functions;
m.GetFunctions(&functions, functions.end());
ASSERT_EQ(1U, functions.size());
@@ -159,7 +159,7 @@
Module::File *file2 = m.FindExistingFile("source-file-name-2");
ASSERT_TRUE(file2 != NULL);
- vector<Module::Function *> functions;
+ vector<Module::Function*> functions;
m.GetFunctions(&functions, functions.end());
ASSERT_EQ((size_t) 1, functions.size());
@@ -204,7 +204,7 @@
Module::File *file = m.FindExistingFile("compilation-unit");
ASSERT_TRUE(file != NULL);
- vector<Module::Function *> functions;
+ vector<Module::Function*> functions;
m.GetFunctions(&functions, functions.end());
ASSERT_EQ(1U, functions.size());
diff --git a/src/common/string_conversion.cc b/src/common/string_conversion.cc
index 11d60a3..6a78ed7 100644
--- a/src/common/string_conversion.cc
+++ b/src/common/string_conversion.cc
@@ -38,15 +38,15 @@
using std::vector;
-void UTF8ToUTF16(const char *in, vector<uint16_t> *out) {
+void UTF8ToUTF16(const char* in, vector<uint16_t>* out) {
size_t source_length = strlen(in);
- const UTF8 *source_ptr = reinterpret_cast<const UTF8 *>(in);
- const UTF8 *source_end_ptr = source_ptr + source_length;
+ const UTF8* source_ptr = reinterpret_cast<const UTF8*>(in);
+ const UTF8* source_end_ptr = source_ptr + source_length;
// Erase the contents and zero fill to the expected size
out->clear();
out->insert(out->begin(), source_length, 0);
- uint16_t *target_ptr = &(*out)[0];
- uint16_t *target_end_ptr = target_ptr + out->capacity();
+ uint16_t* target_ptr = &(*out)[0];
+ uint16_t* target_end_ptr = target_ptr + out->capacity();
ConversionResult result = ConvertUTF8toUTF16(&source_ptr, source_end_ptr,
&target_ptr, target_end_ptr,
strictConversion);
@@ -55,11 +55,11 @@
out->resize(result == conversionOK ? target_ptr - &(*out)[0] + 1: 0);
}
-int UTF8ToUTF16Char(const char *in, int in_length, uint16_t out[2]) {
- const UTF8 *source_ptr = reinterpret_cast<const UTF8 *>(in);
- const UTF8 *source_end_ptr = source_ptr + 1;
- uint16_t *target_ptr = out;
- uint16_t *target_end_ptr = target_ptr + 2;
+int UTF8ToUTF16Char(const char* in, int in_length, uint16_t out[2]) {
+ const UTF8* source_ptr = reinterpret_cast<const UTF8*>(in);
+ const UTF8* source_end_ptr = source_ptr + 1;
+ uint16_t* target_ptr = out;
+ uint16_t* target_end_ptr = target_ptr + 2;
out[0] = out[1] = 0;
// Process one character at a time
@@ -69,28 +69,28 @@
strictConversion);
if (result == conversionOK)
- return static_cast<int>(source_ptr - reinterpret_cast<const UTF8 *>(in));
+ return static_cast<int>(source_ptr - reinterpret_cast<const UTF8*>(in));
// Add another character to the input stream and try again
- source_ptr = reinterpret_cast<const UTF8 *>(in);
+ source_ptr = reinterpret_cast<const UTF8*>(in);
++source_end_ptr;
- if (source_end_ptr > reinterpret_cast<const UTF8 *>(in) + in_length)
+ if (source_end_ptr > reinterpret_cast<const UTF8*>(in) + in_length)
break;
}
return 0;
}
-void UTF32ToUTF16(const wchar_t *in, vector<uint16_t> *out) {
+void UTF32ToUTF16(const wchar_t* in, vector<uint16_t>* out) {
size_t source_length = wcslen(in);
- const UTF32 *source_ptr = reinterpret_cast<const UTF32 *>(in);
- const UTF32 *source_end_ptr = source_ptr + source_length;
+ const UTF32* source_ptr = reinterpret_cast<const UTF32*>(in);
+ const UTF32* source_end_ptr = source_ptr + source_length;
// Erase the contents and zero fill to the expected size
out->clear();
out->insert(out->begin(), source_length, 0);
- uint16_t *target_ptr = &(*out)[0];
- uint16_t *target_end_ptr = target_ptr + out->capacity();
+ uint16_t* target_ptr = &(*out)[0];
+ uint16_t* target_end_ptr = target_ptr + out->capacity();
ConversionResult result = ConvertUTF32toUTF16(&source_ptr, source_end_ptr,
&target_ptr, target_end_ptr,
strictConversion);
@@ -100,10 +100,10 @@
}
void UTF32ToUTF16Char(wchar_t in, uint16_t out[2]) {
- const UTF32 *source_ptr = reinterpret_cast<const UTF32 *>(&in);
- const UTF32 *source_end_ptr = source_ptr + 1;
- uint16_t *target_ptr = out;
- uint16_t *target_end_ptr = target_ptr + 2;
+ const UTF32* source_ptr = reinterpret_cast<const UTF32*>(&in);
+ const UTF32* source_end_ptr = source_ptr + 1;
+ uint16_t* target_ptr = out;
+ uint16_t* target_end_ptr = target_ptr + 2;
out[0] = out[1] = 0;
ConversionResult result = ConvertUTF32toUTF16(&source_ptr, source_end_ptr,
&target_ptr, target_end_ptr,
@@ -118,15 +118,15 @@
return (value >> 8) | static_cast<uint16_t>(value << 8);
}
-string UTF16ToUTF8(const vector<uint16_t> &in, bool swap) {
- const UTF16 *source_ptr = &in[0];
+string UTF16ToUTF8(const vector<uint16_t>& in, bool swap) {
+ const UTF16* source_ptr = &in[0];
scoped_array<uint16_t> source_buffer;
// If we're to swap, we need to make a local copy and swap each byte pair
if (swap) {
int idx = 0;
source_buffer.reset(new uint16_t[in.size()]);
- UTF16 *source_buffer_ptr = source_buffer.get();
+ UTF16* source_buffer_ptr = source_buffer.get();
for (vector<uint16_t>::const_iterator it = in.begin();
it != in.end(); ++it, ++idx)
source_buffer_ptr[idx] = Swap(*it);
@@ -135,17 +135,17 @@
}
// The maximum expansion would be 4x the size of the input string.
- const UTF16 *source_end_ptr = source_ptr + in.size();
+ const UTF16* source_end_ptr = source_ptr + in.size();
size_t target_capacity = in.size() * 4;
scoped_array<UTF8> target_buffer(new UTF8[target_capacity]);
- UTF8 *target_ptr = target_buffer.get();
- UTF8 *target_end_ptr = target_ptr + target_capacity;
+ UTF8* target_ptr = target_buffer.get();
+ UTF8* target_end_ptr = target_ptr + target_capacity;
ConversionResult result = ConvertUTF16toUTF8(&source_ptr, source_end_ptr,
&target_ptr, target_end_ptr,
strictConversion);
if (result == conversionOK) {
- const char *targetPtr = reinterpret_cast<const char *>(target_buffer.get());
+ const char* targetPtr = reinterpret_cast<const char*>(target_buffer.get());
return targetPtr;
}
diff --git a/src/common/string_conversion.h b/src/common/string_conversion.h
index b9ba96a..02d1486 100644
--- a/src/common/string_conversion.h
+++ b/src/common/string_conversion.h
@@ -44,24 +44,24 @@
// Convert |in| to UTF-16 into |out|. Use platform byte ordering. If the
// conversion failed, |out| will be zero length.
-void UTF8ToUTF16(const char *in, vector<uint16_t> *out);
+void UTF8ToUTF16(const char* in, vector<uint16_t>* out);
// Convert at least one character (up to a maximum of |in_length|) from |in|
// to UTF-16 into |out|. Return the number of characters consumed from |in|.
// Any unused characters in |out| will be initialized to 0. No memory will
// be allocated by this routine.
-int UTF8ToUTF16Char(const char *in, int in_length, uint16_t out[2]);
+int UTF8ToUTF16Char(const char* in, int in_length, uint16_t out[2]);
// Convert |in| to UTF-16 into |out|. Use platform byte ordering. If the
// conversion failed, |out| will be zero length.
-void UTF32ToUTF16(const wchar_t *in, vector<uint16_t> *out);
+void UTF32ToUTF16(const wchar_t* in, vector<uint16_t>* out);
// Convert |in| to UTF-16 into |out|. Any unused characters in |out| will be
// initialized to 0. No memory will be allocated by this routine.
void UTF32ToUTF16Char(wchar_t in, uint16_t out[2]);
// Convert |in| to UTF-8. If |swap| is true, swap bytes before converting.
-string UTF16ToUTF8(const vector<uint16_t> &in, bool swap);
+string UTF16ToUTF8(const vector<uint16_t>& in, bool swap);
} // namespace google_breakpad
diff --git a/src/common/test_assembler.cc b/src/common/test_assembler.cc
index 1e783b4..8a48bfb 100644
--- a/src/common/test_assembler.cc
+++ b/src/common/test_assembler.cc
@@ -46,7 +46,7 @@
Label::Label() : value_(new Binding()) { }
Label::Label(uint64_t value) : value_(new Binding(value)) { }
-Label::Label(const Label &label) {
+Label::Label(const Label& label) {
value_ = label.value_;
value_->Acquire();
}
@@ -54,12 +54,12 @@
if (value_->Release()) delete value_;
}
-Label &Label::operator=(uint64_t value) {
+Label& Label::operator=(uint64_t value) {
value_->Set(NULL, value);
return *this;
}
-Label &Label::operator=(const Label &label) {
+Label& Label::operator=(const Label& label) {
value_->Set(label.value_, 0);
return *this;
}
@@ -89,7 +89,7 @@
#define ALWAYS_EVALUATE_AND_ASSERT(x) assert(x)
#endif
-uint64_t Label::operator-(const Label &label) const {
+uint64_t Label::operator-(const Label& label) const {
uint64_t offset;
ALWAYS_EVALUATE_AND_ASSERT(IsKnownOffsetFrom(label, &offset));
return offset;
@@ -101,8 +101,8 @@
return v;
};
-bool Label::IsKnownConstant(uint64_t *value_p) const {
- Binding *base;
+bool Label::IsKnownConstant(uint64_t* value_p) const {
+ Binding* base;
uint64_t addend;
value_->Get(&base, &addend);
if (base != NULL) return false;
@@ -110,9 +110,9 @@
return true;
}
-bool Label::IsKnownOffsetFrom(const Label &label, uint64_t *offset_p) const
+bool Label::IsKnownOffsetFrom(const Label& label, uint64_t* offset_p) const
{
- Binding *label_base, *this_base;
+ Binding* label_base, *this_base;
uint64_t label_addend, this_addend;
label.value_->Get(&label_base, &label_addend);
value_->Get(&this_base, &this_addend);
@@ -135,7 +135,7 @@
delete base_;
}
-void Label::Binding::Set(Binding *binding, uint64_t addend) {
+void Label::Binding::Set(Binding* binding, uint64_t addend) {
if (!base_ && !binding) {
// We're equating two constants. This could be okay.
assert(addend_ == addend);
@@ -183,13 +183,13 @@
}
}
-void Label::Binding::Get(Binding **base, uint64_t *addend) {
+void Label::Binding::Get(Binding** base, uint64_t* addend) {
if (base_ && base_ != this) {
// Recurse to find the end of our reference chain (the root of our
// tree), and then rewrite every binding along the chain to refer
// to it directly, adjusting addends appropriately. (This is why
// this member function isn't this-const.)
- Binding *final_base;
+ Binding* final_base;
uint64_t final_addend;
base_->Get(&final_base, &final_addend);
if (final_base) final_base->Acquire();
@@ -218,14 +218,14 @@
}
}
-Section &Section::Append(Endianness endianness, size_t size, uint64_t number) {
+Section& Section::Append(Endianness endianness, size_t size, uint64_t number) {
InsertEndian(endianness, size, number,
back_insert_iterator<string>(contents_));
return *this;
}
-Section &Section::Append(Endianness endianness, size_t size,
- const Label &label) {
+Section& Section::Append(Endianness endianness, size_t size,
+ const Label& label) {
// If this label's value is known, there's no reason to waste an
// entry in references_ on it.
uint64_t value;
@@ -246,14 +246,14 @@
#define ENDIANNESS(e) ENDIANNESS_ ## e
#define DEFINE_SHORT_APPEND_NUMBER_ENDIAN(e, bits) \
- Section &Section::e ## bits(uint ## bits ## _t v) { \
+ Section& Section::e ## bits(uint ## bits ## _t v) { \
InsertEndian(ENDIANNESS(e), bits / 8, v, \
back_insert_iterator<string>(contents_)); \
return *this; \
}
#define DEFINE_SHORT_APPEND_LABEL_ENDIAN(e, bits) \
- Section &Section::e ## bits(const Label &v) { \
+ Section& Section::e ## bits(const Label& v) { \
return Append(ENDIANNESS(e), bits / 8, v); \
}
@@ -272,13 +272,13 @@
DEFINE_SHORT_APPEND_ENDIAN(B, 64);
#define DEFINE_SHORT_APPEND_NUMBER_DEFAULT(bits) \
- Section &Section::D ## bits(uint ## bits ## _t v) { \
+ Section& Section::D ## bits(uint ## bits ## _t v) { \
InsertEndian(endianness_, bits / 8, v, \
back_insert_iterator<string>(contents_)); \
return *this; \
}
#define DEFINE_SHORT_APPEND_LABEL_DEFAULT(bits) \
- Section &Section::D ## bits(const Label &v) { \
+ Section& Section::D ## bits(const Label& v) { \
return Append(endianness_, bits / 8, v); \
}
#define DEFINE_SHORT_APPEND_DEFAULT(bits) \
@@ -290,7 +290,7 @@
DEFINE_SHORT_APPEND_DEFAULT(32);
DEFINE_SHORT_APPEND_DEFAULT(64);
-Section &Section::Append(const Section §ion) {
+Section& Section::Append(const Section& section) {
size_t base = contents_.size();
contents_.append(section.contents_);
for (vector<Reference>::const_iterator it = section.references_.begin();
@@ -300,7 +300,7 @@
return *this;
}
-Section &Section::LEB128(long long value) {
+Section& Section::LEB128(long long value) {
while (value < -0x40 || 0x3f < value) {
contents_ += (value & 0x7f) | 0x80;
if (value < 0)
@@ -312,7 +312,7 @@
return *this;
}
-Section &Section::ULEB128(uint64_t value) {
+Section& Section::ULEB128(uint64_t value) {
while (value > 0x7f) {
contents_ += (value & 0x7f) | 0x80;
value = (value >> 7);
@@ -321,7 +321,7 @@
return *this;
}
-Section &Section::Align(size_t alignment, uint8_t pad_byte) {
+Section& Section::Align(size_t alignment, uint8_t pad_byte) {
// ALIGNMENT must be a power of two.
assert(((alignment - 1) & alignment) == 0);
size_t new_size = (contents_.size() + alignment - 1) & ~(alignment - 1);
@@ -335,11 +335,11 @@
references_.clear();
}
-bool Section::GetContents(string *contents) {
+bool Section::GetContents(string* contents) {
// For each label reference, find the label's value, and patch it into
// the section's contents.
for (size_t i = 0; i < references_.size(); i++) {
- Reference &r = references_[i];
+ Reference& r = references_[i];
uint64_t value;
if (!r.label.IsKnownConstant(&value)) {
fprintf(stderr, "Undefined label #%zu at offset 0x%zx\n", i, r.offset);
diff --git a/src/common/test_assembler.h b/src/common/test_assembler.h
index 373dbeb..125ef45 100644
--- a/src/common/test_assembler.h
+++ b/src/common/test_assembler.h
@@ -111,7 +111,7 @@
public:
Label(); // An undefined label.
Label(uint64_t value); // A label with a fixed value
- Label(const Label &value); // A label equal to another.
+ Label(const Label& value); // A label equal to another.
~Label();
// Return this label's value; it must be known.
@@ -124,18 +124,18 @@
// former could fail if the label is not yet defined and the latter won't.
uint64_t Value() const;
- Label &operator=(uint64_t value);
- Label &operator=(const Label &value);
+ Label& operator=(uint64_t value);
+ Label& operator=(const Label& value);
Label operator+(uint64_t addend) const;
Label operator-(uint64_t subtrahend) const;
- uint64_t operator-(const Label &subtrahend) const;
+ uint64_t operator-(const Label& subtrahend) const;
// We could also provide == and != that work on undefined, but
// related, labels.
// Return true if this label's value is known. If VALUE_P is given,
// set *VALUE_P to the known value if returning true.
- bool IsKnownConstant(uint64_t *value_p = NULL) const;
+ bool IsKnownConstant(uint64_t* value_p = NULL) const;
// Return true if the offset from LABEL to this label is known. If
// OFFSET_P is given, set *OFFSET_P to the offset when returning true.
@@ -155,7 +155,7 @@
// l-m // -10
// m-l // 10
// m.Value() // error: m's value is not known
- bool IsKnownOffsetFrom(const Label &label, uint64_t *offset_p = NULL) const;
+ bool IsKnownOffsetFrom(const Label& label, uint64_t* offset_p = NULL) const;
private:
// A label's value, or if that is not yet known, how the value is
@@ -186,7 +186,7 @@
// Update every binding on this binding's chain to point directly
// to BINDING, or to be a constant, with addends adjusted
// appropriately.
- void Set(Binding *binding, uint64_t value);
+ void Set(Binding* binding, uint64_t value);
// Return what we know about the value of this binding.
// - If this binding's value is a known constant, set BASE to
@@ -198,7 +198,7 @@
// value.
// - If this binding is unconstrained, set BASE to this, and leave
// ADDEND unchanged.
- void Get(Binding **base, uint64_t *addend);
+ void Get(Binding** base, uint64_t* addend);
private:
// There are three cases:
@@ -220,7 +220,7 @@
// operations on bindings do path compression: they change every
// binding on the chain to point directly to the final value,
// adjusting addends as appropriate.
- Binding *base_;
+ Binding* base_;
uint64_t addend_;
// The number of Labels and Bindings pointing to this binding.
@@ -230,10 +230,10 @@
};
// This label's value.
- Binding *value_;
+ Binding* value_;
};
-inline Label operator+(uint64_t a, const Label &l) { return l + a; }
+inline Label operator+(uint64_t a, const Label& l) { return l + a; }
// Note that int-Label isn't defined, as negating a Label is not an
// operation we support.
@@ -288,18 +288,18 @@
// Append the SIZE bytes at DATA or the contents of STRING to the
// end of this section. Return a reference to this section.
- Section &Append(const uint8_t *data, size_t size) {
- contents_.append(reinterpret_cast<const char *>(data), size);
+ Section& Append(const uint8_t* data, size_t size) {
+ contents_.append(reinterpret_cast<const char*>(data), size);
return *this;
};
- Section &Append(const string &data) {
+ Section& Append(const string& data) {
contents_.append(data);
return *this;
};
// Append SIZE copies of BYTE to the end of this section. Return a
// reference to this section.
- Section &Append(size_t size, uint8_t byte) {
+ Section& Append(size_t size, uint8_t byte) {
contents_.append(size, (char) byte);
return *this;
}
@@ -307,8 +307,8 @@
// Append NUMBER to this section. ENDIANNESS is the endianness to
// use to write the number. SIZE is the length of the number in
// bytes. Return a reference to this section.
- Section &Append(Endianness endianness, size_t size, uint64_t number);
- Section &Append(Endianness endianness, size_t size, const Label &label);
+ Section& Append(Endianness endianness, size_t size, uint64_t number);
+ Section& Append(Endianness endianness, size_t size, const Label& label);
// Append SECTION to the end of this section. The labels SECTION
// refers to need not be defined yet.
@@ -317,11 +317,11 @@
// SECTION. If placing SECTION within 'this' provides new
// constraints on existing labels' values, then it's up to the
// caller to fiddle with those labels as needed.
- Section &Append(const Section §ion);
+ Section& Append(const Section& section);
// Append the contents of DATA as a series of bytes terminated by
// a NULL character.
- Section &AppendCString(const string &data) {
+ Section& AppendCString(const string& data) {
Append(data);
contents_ += '\0';
return *this;
@@ -329,7 +329,7 @@
// Append at most SIZE bytes from DATA; if DATA is less than SIZE bytes
// long, pad with '\0' characters.
- Section &AppendCString(const string &data, size_t size) {
+ Section& AppendCString(const string& data, size_t size) {
contents_.append(data, 0, size);
if (data.size() < size)
Append(size - data.size(), 0);
@@ -352,18 +352,18 @@
// the compiler will properly sign-extend a signed value before
// passing it to the function, at which point the function's
// behavior is the same either way.
- Section &L8(uint8_t value) { contents_ += value; return *this; }
- Section &B8(uint8_t value) { contents_ += value; return *this; }
- Section &D8(uint8_t value) { contents_ += value; return *this; }
+ Section& L8(uint8_t value) { contents_ += value; return *this; }
+ Section& B8(uint8_t value) { contents_ += value; return *this; }
+ Section& D8(uint8_t value) { contents_ += value; return *this; }
Section &L16(uint16_t), &L32(uint32_t), &L64(uint64_t),
&B16(uint16_t), &B32(uint32_t), &B64(uint64_t),
&D16(uint16_t), &D32(uint32_t), &D64(uint64_t);
- Section &L8(const Label &label), &L16(const Label &label),
- &L32(const Label &label), &L64(const Label &label),
- &B8(const Label &label), &B16(const Label &label),
- &B32(const Label &label), &B64(const Label &label),
- &D8(const Label &label), &D16(const Label &label),
- &D32(const Label &label), &D64(const Label &label);
+ Section &L8(const Label& label), &L16(const Label& label),
+ &L32(const Label& label), &L64(const Label& label),
+ &B8(const Label& label), &B16(const Label& label),
+ &B32(const Label& label), &B64(const Label& label),
+ &D8(const Label& label), &D16(const Label& label),
+ &D32(const Label& label), &D64(const Label& label);
// Append VALUE in a signed LEB128 (Little-Endian Base 128) form.
//
@@ -383,7 +383,7 @@
//
// Note that VALUE cannot be a Label (we would have to implement
// relaxation).
- Section &LEB128(long long value);
+ Section& LEB128(long long value);
// Append VALUE in unsigned LEB128 (Little-Endian Base 128) form.
//
@@ -399,13 +399,13 @@
//
// Note that VALUE cannot be a Label (we would have to implement
// relaxation).
- Section &ULEB128(uint64_t value);
+ Section& ULEB128(uint64_t value);
// Jump to the next location aligned on an ALIGNMENT-byte boundary,
// relative to the start of the section. Fill the gap with PAD_BYTE.
// ALIGNMENT must be a power of two. Return a reference to this
// section.
- Section &Align(size_t alignment, uint8_t pad_byte = 0);
+ Section& Align(size_t alignment, uint8_t pad_byte = 0);
// Clear the contents of this section.
void Clear();
@@ -436,19 +436,19 @@
Label Here() const { return start_ + Size(); }
// Set *LABEL to Here, and return a reference to this section.
- Section &Mark(Label *label) { *label = Here(); return *this; }
+ Section& Mark(Label* label) { *label = Here(); return *this; }
// If there are no undefined label references left in this
// section, set CONTENTS to the contents of this section, as a
// string, and clear this section. Return true on success, or false
// if there were still undefined labels.
- bool GetContents(string *contents);
+ bool GetContents(string* contents);
private:
// Used internally. A reference to a label's value.
struct Reference {
Reference(size_t set_offset, Endianness set_endianness, size_t set_size,
- const Label &set_label)
+ const Label& set_label)
: offset(set_offset), endianness(set_endianness), size(set_size),
label(set_label) { }
diff --git a/src/common/test_assembler_unittest.cc b/src/common/test_assembler_unittest.cc
index 94b5a5c..bda25eb 100644
--- a/src/common/test_assembler_unittest.cc
+++ b/src/common/test_assembler_unittest.cc
@@ -755,7 +755,7 @@
{ \
static const uint8_t expected_bytes[] = b; \
ASSERT_EQ(sizeof(expected_bytes), s.size()); \
- ASSERT_TRUE(memcmp(s.data(), (const char *) expected_bytes, \
+ ASSERT_TRUE(memcmp(s.data(), (const char*) expected_bytes, \
sizeof(expected_bytes)) == 0); \
} \
while(0)
@@ -766,7 +766,7 @@
section.Append(data, sizeof(data));
ASSERT_TRUE(section.GetContents(&contents));
ASSERT_EQ(sizeof(data), contents.size());
- EXPECT_TRUE(0 == memcmp(contents.data(), (const char *) data, sizeof(data)));
+ EXPECT_TRUE(0 == memcmp(contents.data(), (const char*) data, sizeof(data)));
}
TEST_F(Append, BytesTwice) {
@@ -774,9 +774,9 @@
section.Append(data, sizeof(data));
ASSERT_TRUE(section.GetContents(&contents));
ASSERT_EQ(2 * sizeof(data), contents.size());
- ASSERT_TRUE(0 == memcmp(contents.data(), (const char *) data, sizeof(data)));
+ ASSERT_TRUE(0 == memcmp(contents.data(), (const char*) data, sizeof(data)));
ASSERT_TRUE(0 == memcmp(contents.data() + sizeof(data),
- (const char *) data, sizeof(data)));
+ (const char*) data, sizeof(data)));
}
TEST_F(Append, String) {
diff --git a/src/common/windows/http_upload.cc b/src/common/windows/http_upload.cc
index b0cc907..efee0d5 100644
--- a/src/common/windows/http_upload.cc
+++ b/src/common/windows/http_upload.cc
@@ -65,7 +65,7 @@
HINTERNET handle_;
};
- wstring UTF8ToWide(const string &utf8) {
+ wstring UTF8ToWide(const string& utf8) {
if (utf8.length() == 0) {
return wstring();
}
@@ -85,7 +85,7 @@
return result;
}
- string WideToMBCP(const wstring &wide, unsigned int cp) {
+ string WideToMBCP(const wstring& wide, unsigned int cp) {
if (wide.length() == 0) {
return string();
}
@@ -107,7 +107,7 @@
return result;
}
- bool GetFileContents(const wstring &filename, vector<char> *contents) {
+ bool GetFileContents(const wstring& filename, vector<char>* contents) {
bool rv = false;
// The "open" method on pre-MSVC8 ifstream implementations doesn't accept a
// wchar_t* filename, so use _wfopen directly in that case. For VC8 and
@@ -141,10 +141,10 @@
return rv;
}
- bool CheckParameters(const map<wstring, wstring> ¶meters) {
+ bool CheckParameters(const map<wstring, wstring>& parameters) {
for (map<wstring, wstring>::const_iterator pos = parameters.begin();
pos != parameters.end(); ++pos) {
- const wstring &str = pos->first;
+ const wstring& str = pos->first;
if (str.size() == 0) {
return false; // disallow empty parameter names
}
@@ -159,7 +159,7 @@
}
// Converts a UTF16 string to UTF8.
- string WideToUTF8(const wstring &wide) {
+ string WideToUTF8(const wstring& wide) {
return WideToMBCP(wide, CP_UTF8);
}
@@ -305,7 +305,7 @@
}
if (!HttpSendRequest(request.get(), NULL, 0,
- const_cast<char *>(request_body.data()),
+ const_cast<char*>(request_body.data()),
static_cast<DWORD>(request_body.size()))) {
return false;
}
@@ -351,7 +351,7 @@
return wstring(temp);
}
- wstring GenerateMultipartPostRequestHeader(const wstring &boundary) {
+ wstring GenerateMultipartPostRequestHeader(const wstring& boundary) {
wstring header = L"Content-Type: multipart/form-data; boundary=";
header += boundary;
return header;
@@ -390,9 +390,9 @@
return true;
}
- bool GenerateRequestBody(const map<wstring, wstring> ¶meters,
- const map<wstring, wstring> &files,
- const wstring &boundary,
+ bool GenerateRequestBody(const map<wstring, wstring>& parameters,
+ const map<wstring, wstring>& files,
+ const wstring& boundary,
string *request_body) {
string boundary_str = WideToUTF8(boundary);
if (boundary_str.empty()) {
diff --git a/src/common/windows/http_upload.h b/src/common/windows/http_upload.h
index 57e526e..c7d8c6f 100644
--- a/src/common/windows/http_upload.h
+++ b/src/common/windows/http_upload.h
@@ -114,8 +114,8 @@
// No instances of this class should be created.
// Disallow all constructors, destructors, and operator=.
HTTPUpload();
- explicit HTTPUpload(const HTTPUpload &);
- void operator=(const HTTPUpload &);
+ explicit HTTPUpload(const HTTPUpload&);
+ void operator=(const HTTPUpload&);
~HTTPUpload();
};
diff --git a/src/common/windows/omap.cc b/src/common/windows/omap.cc
index ba3ce86..5a821b6 100644
--- a/src/common/windows/omap.cc
+++ b/src/common/windows/omap.cc
@@ -449,11 +449,11 @@
}
}
-void BuildSubsequentRVAMap(const OmapData &omap_data,
- std::map<DWORD, DWORD> *subsequent) {
+void BuildSubsequentRVAMap(const OmapData& omap_data,
+ std::map<DWORD, DWORD>* subsequent) {
assert(subsequent->empty());
- const OmapFromTable &orig2tran =
- reinterpret_cast<const OmapFromTable &>(omap_data.omap_from);
+ const OmapFromTable& orig2tran =
+ reinterpret_cast<const OmapFromTable&>(omap_data.omap_from);
if (orig2tran.empty())
return;
diff --git a/src/common/windows/pdb_source_line_writer.cc b/src/common/windows/pdb_source_line_writer.cc
index 4030a2e..0eeb30c 100644
--- a/src/common/windows/pdb_source_line_writer.cc
+++ b/src/common/windows/pdb_source_line_writer.cc
@@ -120,7 +120,7 @@
return a_section == b_section && a_offset == b_offset;
}
-bool CreateDiaDataSourceInstance(CComPtr<IDiaDataSource> &data_source) {
+bool CreateDiaDataSourceInstance(CComPtr<IDiaDataSource>& data_source) {
if (SUCCEEDED(data_source.CoCreateInstance(CLSID_DiaSource))) {
return true;
}
@@ -134,7 +134,7 @@
// We can try loading the DLL corresponding to the #included DIA SDK, but
// the DIA headers don't provide a version. Lets try to figure out which DIA
// version we're compiling against by comparing CLSIDs.
- const wchar_t *msdia_dll = nullptr;
+ const wchar_t* msdia_dll = nullptr;
if (CLSID_DiaSource == _uuidof(DiaSource100)) {
msdia_dll = L"msdia100.dll";
} else if (CLSID_DiaSource == _uuidof(DiaSource110)) {
@@ -147,7 +147,7 @@
if (msdia_dll &&
SUCCEEDED(NoRegCoCreate(msdia_dll, CLSID_DiaSource, IID_IDiaDataSource,
- reinterpret_cast<void **>(&data_source)))) {
+ reinterpret_cast<void**>(&data_source)))) {
return true;
}
@@ -163,7 +163,7 @@
Close();
}
-bool PDBSourceLineWriter::SetCodeFile(const wstring &exe_file) {
+bool PDBSourceLineWriter::SetCodeFile(const wstring& exe_file) {
if (code_file_.empty()) {
code_file_ = exe_file;
return true;
@@ -173,7 +173,7 @@
return exe_file == code_file_;
}
-bool PDBSourceLineWriter::Open(const wstring &file, FileFormat format) {
+bool PDBSourceLineWriter::Open(const wstring& file, FileFormat format) {
Close();
code_file_.clear();
@@ -228,7 +228,7 @@
return true;
}
-bool PDBSourceLineWriter::PrintLines(IDiaEnumLineNumbers *lines) {
+bool PDBSourceLineWriter::PrintLines(IDiaEnumLineNumbers* lines) {
// The line number format is:
// <rva> <line number> <source file id>
CComPtr<IDiaLineNumber> line;
@@ -272,8 +272,8 @@
return true;
}
-bool PDBSourceLineWriter::PrintFunction(IDiaSymbol *function,
- IDiaSymbol *block,
+bool PDBSourceLineWriter::PrintFunction(IDiaSymbol* function,
+ IDiaSymbol* block,
bool has_multiple_symbols) {
// The function format is:
// FUNC <address> <length> <param_stack_size> <function>
@@ -679,7 +679,7 @@
return false;
}
-bool PDBSourceLineWriter::PrintCodePublicSymbol(IDiaSymbol *symbol,
+bool PDBSourceLineWriter::PrintCodePublicSymbol(IDiaSymbol* symbol,
bool has_multiple_symbols) {
BOOL is_code;
if (FAILED(symbol->get_code(&is_code))) {
@@ -781,9 +781,9 @@
// and scanf families, which are not as strict about input and in some cases
// don't provide a good way for the caller to determine if a conversion was
// successful.
-static bool wcstol_positive_strict(wchar_t *string, int *result) {
+static bool wcstol_positive_strict(wchar_t* string, int* result) {
int value = 0;
- for (wchar_t *c = string; *c != '\0'; ++c) {
+ for (wchar_t* c = string; *c != '\0'; ++c) {
int last_value = value;
value *= 10;
// Detect overflow.
@@ -821,7 +821,7 @@
wstring file(symbols_file);
// Look for an EXE or DLL file.
- const wchar_t *extensions[] = { L"exe", L"dll" };
+ const wchar_t* extensions[] = { L"exe", L"dll" };
for (size_t i = 0; i < sizeof(extensions) / sizeof(extensions[0]); i++) {
size_t dot_pos = file.find_last_of(L".");
if (dot_pos != wstring::npos) {
@@ -839,9 +839,9 @@
}
// static
-bool PDBSourceLineWriter::GetSymbolFunctionName(IDiaSymbol *function,
- BSTR *name,
- int *stack_param_size) {
+bool PDBSourceLineWriter::GetSymbolFunctionName(IDiaSymbol* function,
+ BSTR* name,
+ int* stack_param_size) {
*stack_param_size = -1;
const DWORD undecorate_options = UNDNAME_NO_MS_KEYWORDS |
UNDNAME_NO_FUNCTION_RETURNS |
@@ -882,12 +882,12 @@
// C++ uses a bogus "void" argument for functions and methods that don't
// take any parameters. Take it out of the undecorated name because it's
// ugly and unnecessary.
- const wchar_t *replace_string = L"(void)";
+ const wchar_t* replace_string = L"(void)";
const size_t replace_length = wcslen(replace_string);
- const wchar_t *replacement_string = L"()";
+ const wchar_t* replacement_string = L"()";
size_t length = wcslen(*name);
if (length >= replace_length) {
- wchar_t *name_end = *name + length - replace_length;
+ wchar_t* name_end = *name + length - replace_length;
if (wcscmp(name_end, replace_string) == 0) {
WindowsStringUtils::safe_wcscpy(name_end, replace_length,
replacement_string);
@@ -903,7 +903,7 @@
// whether the undecorated name contains any ':' or '(' characters.
if (!wcschr(*name, ':') && !wcschr(*name, '(') &&
(*name[0] == '_' || *name[0] == '@')) {
- wchar_t *last_at = wcsrchr(*name + 1, '@');
+ wchar_t* last_at = wcsrchr(*name + 1, '@');
if (last_at && wcstol_positive_strict(last_at + 1, stack_param_size)) {
// If this function adheres to the fastcall convention, it accepts up
// to the first 8 bytes of parameters in registers (%ecx and %edx).
@@ -935,7 +935,7 @@
}
// static
-int PDBSourceLineWriter::GetFunctionStackParamSize(IDiaSymbol *function) {
+int PDBSourceLineWriter::GetFunctionStackParamSize(IDiaSymbol* function) {
// This implementation is highly x86-specific.
// Gather the symbols corresponding to data.
@@ -1050,7 +1050,7 @@
return param_size;
}
-bool PDBSourceLineWriter::WriteSymbols(FILE *symbol_file) {
+bool PDBSourceLineWriter::WriteSymbols(FILE* symbol_file) {
output_ = symbol_file;
// Load the OMAP information, and disable auto-translation of addresses in
@@ -1078,7 +1078,7 @@
}
}
-bool PDBSourceLineWriter::GetModuleInfo(PDBModuleInfo *info) {
+bool PDBSourceLineWriter::GetModuleInfo(PDBModuleInfo* info) {
if (!info) {
return false;
}
@@ -1143,7 +1143,7 @@
return true;
}
-bool PDBSourceLineWriter::GetPEInfo(PEModuleInfo *info) {
+bool PDBSourceLineWriter::GetPEInfo(PEModuleInfo* info) {
if (!info) {
return false;
}
@@ -1156,7 +1156,7 @@
return ReadPEInfo(code_file_, info);
}
-bool PDBSourceLineWriter::UsesGUID(bool *uses_guid) {
+bool PDBSourceLineWriter::UsesGUID(bool* uses_guid) {
if (!uses_guid)
return false;
diff --git a/src/common/windows/pdb_source_line_writer.h b/src/common/windows/pdb_source_line_writer.h
index c0adf29..00f6e59 100644
--- a/src/common/windows/pdb_source_line_writer.h
+++ b/src/common/windows/pdb_source_line_writer.h
@@ -65,7 +65,7 @@
// file must be available; Open will be if it is not.
// If there is already a pdb file open, it is automatically closed.
// Returns true on success.
- bool Open(const wstring &file, FileFormat format);
+ bool Open(const wstring& file, FileFormat format);
// Closes the current pdb file and its associated resources.
void Close();
@@ -77,7 +77,7 @@
// file and it must be called after Open() and before WriteMap().
// If Open() was called for an executable file, then it is an error to call
// SetCodeFile() with a different file path and it will return false.
- bool SetCodeFile(const wstring &exe_file);
+ bool SetCodeFile(const wstring& exe_file);
// Writes a Breakpad symbol file from the current pdb file to |symbol_file|.
// Returns true on success.
@@ -150,17 +150,17 @@
// Returns true if this filename has already been seen,
// and an ID is stored for it, or false if it has not.
- bool FileIDIsCached(const wstring &file) {
+ bool FileIDIsCached(const wstring& file) {
return unique_files_.find(file) != unique_files_.end();
}
// Cache this filename and ID for later reuse.
- void CacheFileID(const wstring &file, DWORD id) {
+ void CacheFileID(const wstring& file, DWORD id) {
unique_files_[file] = id;
}
// Store this ID in the cache as a duplicate for this filename.
- void StoreDuplicateFileID(const wstring &file, DWORD id) {
+ void StoreDuplicateFileID(const wstring& file, DWORD id) {
unordered_map<wstring, DWORD>::iterator iter = unique_files_.find(file);
if (iter != unique_files_.end()) {
// map this id to the previously seen one
diff --git a/src/common/windows/pe_util.cc b/src/common/windows/pe_util.cc
index 6fa63fa..9c94af0 100644
--- a/src/common/windows/pe_util.cc
+++ b/src/common/windows/pe_util.cc
@@ -285,7 +285,7 @@
unwind_rva = chained_func->UnwindInfoAddress;
}
- UnwindInfo *unwind_info = static_cast<UnwindInfo *>(
+ UnwindInfo *unwind_info = static_cast<UnwindInfo*>(
ImageRvaToVa(img->FileHeader,
img->MappedAddress,
unwind_rva,
@@ -351,7 +351,7 @@
(unwind_info->unwind_code +
((unwind_info->count_of_codes + 1) & ~1)));
- unwind_info = static_cast<UnwindInfo *>(
+ unwind_info = static_cast<UnwindInfo*>(
ImageRvaToVa(img->FileHeader,
img->MappedAddress,
chained_func->UnwindInfoAddress,
diff --git a/src/common/windows/string_utils-inl.h b/src/common/windows/string_utils-inl.h
index 9b63607..935e19f 100644
--- a/src/common/windows/string_utils-inl.h
+++ b/src/common/windows/string_utils-inl.h
@@ -72,26 +72,26 @@
// Roughly equivalent to MSVC8's wcscpy_s, except pre-MSVC8, this does
// not fail if source is longer than destination_size. The destination
// buffer is always 0-terminated.
- static void safe_wcscpy(wchar_t *destination, size_t destination_size,
- const wchar_t *source);
+ static void safe_wcscpy(wchar_t* destination, size_t destination_size,
+ const wchar_t* source);
// Roughly equivalent to MSVC8's wcsncpy_s, except that _TRUNCATE cannot
// be passed directly, and pre-MSVC8, this will not fail if source or count
// are longer than destination_size. The destination buffer is always
// 0-terminated.
- static void safe_wcsncpy(wchar_t *destination, size_t destination_size,
- const wchar_t *source, size_t count);
+ static void safe_wcsncpy(wchar_t* destination, size_t destination_size,
+ const wchar_t* source, size_t count);
// Performs multi-byte to wide character conversion on C++ strings, using
// mbstowcs_s (MSVC8) or mbstowcs (pre-MSVC8). Returns false on failure,
// without setting wcs.
- static bool safe_mbstowcs(const string &mbs, wstring *wcs);
+ static bool safe_mbstowcs(const string& mbs, wstring* wcs);
// The inverse of safe_mbstowcs.
- static bool safe_wcstombs(const wstring &wcs, string *mbs);
+ static bool safe_wcstombs(const wstring& wcs, string* mbs);
// Returns the base name of a file, e.g. strips off the path.
- static wstring GetBaseName(const wstring &filename);
+ static wstring GetBaseName(const wstring& filename);
private:
// Disallow instantiation and other object-based operations.
@@ -102,9 +102,9 @@
};
// static
-inline void WindowsStringUtils::safe_wcscpy(wchar_t *destination,
+inline void WindowsStringUtils::safe_wcscpy(wchar_t* destination,
size_t destination_size,
- const wchar_t *source) {
+ const wchar_t* source) {
#if _MSC_VER >= 1400 // MSVC 2005/8
wcscpy_s(destination, destination_size, source);
#else // _MSC_VER >= 1400
@@ -118,9 +118,9 @@
}
// static
-inline void WindowsStringUtils::safe_wcsncpy(wchar_t *destination,
+inline void WindowsStringUtils::safe_wcsncpy(wchar_t* destination,
size_t destination_size,
- const wchar_t *source,
+ const wchar_t* source,
size_t count) {
#if _MSC_VER >= 1400 // MSVC 2005/8
wcsncpy_s(destination, destination_size, source, count);
diff --git a/src/common/windows/string_utils.cc b/src/common/windows/string_utils.cc
index 2728000..90aab03 100644
--- a/src/common/windows/string_utils.cc
+++ b/src/common/windows/string_utils.cc
@@ -35,7 +35,7 @@
namespace google_breakpad {
// static
-wstring WindowsStringUtils::GetBaseName(const wstring &filename) {
+wstring WindowsStringUtils::GetBaseName(const wstring& filename) {
wstring base_name(filename);
size_t slash_pos = base_name.find_last_of(L"/\\");
if (slash_pos != wstring::npos) {
@@ -45,7 +45,7 @@
}
// static
-bool WindowsStringUtils::safe_mbstowcs(const string &mbs, wstring *wcs) {
+bool WindowsStringUtils::safe_mbstowcs(const string& mbs, wstring* wcs) {
assert(wcs);
// First, determine the length of the destination buffer.
@@ -88,7 +88,7 @@
}
// static
-bool WindowsStringUtils::safe_wcstombs(const wstring &wcs, string *mbs) {
+bool WindowsStringUtils::safe_wcstombs(const wstring& wcs, string* mbs) {
assert(mbs);
// First, determine the length of the destination buffer.
diff --git a/src/google_breakpad/processor/basic_source_line_resolver.h b/src/google_breakpad/processor/basic_source_line_resolver.h
index 91fb784..1c7bf46 100644
--- a/src/google_breakpad/processor/basic_source_line_resolver.h
+++ b/src/google_breakpad/processor/basic_source_line_resolver.h
@@ -90,9 +90,9 @@
// can't be const. On success, <id>, and <filename> are stored in |*index|,
// and |*filename|. No allocation is done, |*filename| simply points inside
// |file_line|.
- static bool ParseFile(char *file_line, // in
- long *index, // out
- char **filename); // out
+ static bool ParseFile(char* file_line, // in
+ long* index, // out
+ char** filename); // out
// Parses a |function_line| declaration. Returns true on success.
// Format: FUNC [<multiple>] <address> <size> <stack_param_size> <name>.
@@ -101,12 +101,12 @@
// <stack_param_size>, and <name> are stored in |*is_multiple|, |*address|,
// |*size|, |*stack_param_size|, and |*name|. No allocation is done, |*name|
// simply points inside |function_line|.
- static bool ParseFunction(char *function_line, // in
- bool *is_multiple, // out
- uint64_t *address, // out
- uint64_t *size, // out
- long *stack_param_size, // out
- char **name); // out
+ static bool ParseFunction(char* function_line, // in
+ bool* is_multiple, // out
+ uint64_t* address, // out
+ uint64_t* size, // out
+ long* stack_param_size, // out
+ char** name); // out
// Parses a |line| declaration. Returns true on success.
// Format: <address> <size> <line number> <source file id>
@@ -114,11 +114,11 @@
// it can't be const. On success, <address>, <size>, <line number>, and
// <source file id> are stored in |*address|, |*size|, |*line_number|, and
// |*source_file|.
- static bool ParseLine(char *line_line, // in
- uint64_t *address, // out
- uint64_t *size, // out
- long *line_number, // out
- long *source_file); // out
+ static bool ParseLine(char* line_line, // in
+ uint64_t* address, // out
+ uint64_t* size, // out
+ long* line_number, // out
+ long* source_file); // out
// Parses a |public_line| declaration. Returns true on success.
// Format: PUBLIC [<multiple>] <address> <stack_param_size> <name>
@@ -127,15 +127,15 @@
// <stack_param_size>, <name> are stored in |*is_multiple|, |*address|,
// |*stack_param_size|, and |*name|. No allocation is done, |*name| simply
// points inside |public_line|.
- static bool ParsePublicSymbol(char *public_line, // in
- bool *is_multiple, // out
- uint64_t *address, // out
- long *stack_param_size, // out
- char **name); // out
+ static bool ParsePublicSymbol(char* public_line, // in
+ bool* is_multiple, // out
+ uint64_t* address, // out
+ long* stack_param_size, // out
+ char** name); // out
private:
// Used for success checks after strtoull and strtol.
- static bool IsValidAfterNumber(char *after_number);
+ static bool IsValidAfterNumber(char* after_number);
// Only allow static methods.
SymbolParseHelper();
diff --git a/src/google_breakpad/processor/minidump.h b/src/google_breakpad/processor/minidump.h
index d712cb6..1c40a82 100644
--- a/src/google_breakpad/processor/minidump.h
+++ b/src/google_breakpad/processor/minidump.h
@@ -291,7 +291,7 @@
// so a special getter is provided to retrieve this data from the
// MDRawThread structure. Returns false if the thread ID cannot be
// determined.
- virtual bool GetThreadID(uint32_t *thread_id) const;
+ virtual bool GetThreadID(uint32_t* thread_id) const;
// Print a human-readable representation of the object to stdout.
void Print();
@@ -549,9 +549,9 @@
static uint32_t max_modules_;
// Access to modules using addresses as the key.
- RangeMap<uint64_t, unsigned int> *range_map_;
+ RangeMap<uint64_t, unsigned int>* range_map_;
- MinidumpModules *modules_;
+ MinidumpModules* modules_;
uint32_t module_count_;
DISALLOW_COPY_AND_ASSIGN(MinidumpModuleList);
@@ -606,16 +606,16 @@
static uint32_t max_regions_;
// Access to memory regions using addresses as the key.
- RangeMap<uint64_t, unsigned int> *range_map_;
+ RangeMap<uint64_t, unsigned int>* range_map_;
// The list of descriptors. This is maintained separately from the list
// of regions, because MemoryRegion doesn't own its MemoryDescriptor, it
// maintains a pointer to it. descriptors_ provides the storage for this
// purpose.
- MemoryDescriptors *descriptors_;
+ MemoryDescriptors* descriptors_;
// The list of regions.
- MemoryRegions *regions_;
+ MemoryRegions* regions_;
uint32_t region_count_;
DISALLOW_COPY_AND_ASSIGN(MinidumpMemoryList);
@@ -640,7 +640,7 @@
// so a special getter is provided to retrieve this data from the
// MDRawExceptionStream structure. Returns false if the thread ID cannot
// be determined.
- bool GetThreadID(uint32_t *thread_id) const;
+ bool GetThreadID(uint32_t* thread_id) const;
MinidumpContext* GetContext();
@@ -862,9 +862,9 @@
static uint32_t max_modules_;
// Access to module indices using addresses as the key.
- RangeMap<uint64_t, unsigned int> *range_map_;
+ RangeMap<uint64_t, unsigned int>* range_map_;
- MinidumpUnloadedModules *unloaded_modules_;
+ MinidumpUnloadedModules* unloaded_modules_;
uint32_t module_count_;
DISALLOW_COPY_AND_ASSIGN(MinidumpUnloadedModuleList);
@@ -919,8 +919,8 @@
// treatment, so special getters are provided to retrieve this data from
// the MDRawBreakpadInfo structure. The getters return false if the thread
// IDs cannot be determined.
- bool GetDumpThreadID(uint32_t *thread_id) const;
- bool GetRequestingThreadID(uint32_t *thread_id) const;
+ bool GetDumpThreadID(uint32_t* thread_id) const;
+ bool GetRequestingThreadID(uint32_t* thread_id) const;
// Print a human-readable representation of the object to stdout.
void Print();
@@ -1003,7 +1003,7 @@
bool Read(uint32_t expected_size) override;
// Access to memory info using addresses as the key.
- RangeMap<uint64_t, unsigned int> *range_map_;
+ RangeMap<uint64_t, unsigned int>* range_map_;
MinidumpMemoryInfos* infos_;
uint32_t info_count_;
@@ -1056,7 +1056,7 @@
friend class MinidumpLinuxMapsList;
// This caller owns the pointer.
- explicit MinidumpLinuxMaps(Minidump *minidump);
+ explicit MinidumpLinuxMaps(Minidump* minidump);
// The memory region struct that this class wraps.
MappedMemoryRegion region_;
@@ -1075,9 +1075,9 @@
unsigned int get_maps_count() const { return valid_ ? maps_count_ : 0; }
// Get mapping at the given memory address. The caller owns the pointer.
- const MinidumpLinuxMaps *GetLinuxMapsForAddress(uint64_t address) const;
+ const MinidumpLinuxMaps* GetLinuxMapsForAddress(uint64_t address) const;
// Get mapping at the given index. The caller owns the pointer.
- const MinidumpLinuxMaps *GetLinuxMapsAtIndex(unsigned int index) const;
+ const MinidumpLinuxMaps* GetLinuxMapsAtIndex(unsigned int index) const;
// Print the contents of /proc/self/maps to stdout.
void Print() const;
@@ -1085,12 +1085,12 @@
private:
friend class Minidump;
- typedef vector<MinidumpLinuxMaps *> MinidumpLinuxMappings;
+ typedef vector<MinidumpLinuxMaps*> MinidumpLinuxMappings;
static const uint32_t kStreamType = MD_LINUX_MAPS;
// The caller owns the pointer.
- explicit MinidumpLinuxMapsList(Minidump *minidump);
+ explicit MinidumpLinuxMapsList(Minidump* minidump);
// Read and load the contents of the process mapping data.
// The stream should have data in the form of /proc/self/maps.
@@ -1098,7 +1098,7 @@
bool Read(uint32_t expected_size) override;
// The list of individual mappings.
- MinidumpLinuxMappings *maps_;
+ MinidumpLinuxMappings* maps_;
// The number of mappings.
uint32_t maps_count_;
@@ -1200,7 +1200,7 @@
MinidumpCrashpadInfo* GetCrashpadInfo();
// The next method also calls GetStream, but is exclusive for Linux dumps.
- virtual MinidumpLinuxMapsList *GetLinuxMapsList();
+ virtual MinidumpLinuxMapsList* GetLinuxMapsList();
// The next set of methods are provided for users who wish to access
// data in minidump files directly, while leveraging the rest of
diff --git a/src/google_breakpad/processor/minidump_processor.h b/src/google_breakpad/processor/minidump_processor.h
index 387115e..414050e 100644
--- a/src/google_breakpad/processor/minidump_processor.h
+++ b/src/google_breakpad/processor/minidump_processor.h
@@ -70,7 +70,7 @@
~MinidumpProcessor();
// Processes the minidump file and fills process_state with the result.
- ProcessResult Process(const string &minidump_file,
+ ProcessResult Process(const string& minidump_file,
ProcessState* process_state);
// Processes the minidump structure and fills process_state with the
diff --git a/src/google_breakpad/processor/source_line_resolver_base.h b/src/google_breakpad/processor/source_line_resolver_base.h
index c720b0c..fea1657 100644
--- a/src/google_breakpad/processor/source_line_resolver_base.h
+++ b/src/google_breakpad/processor/source_line_resolver_base.h
@@ -64,36 +64,36 @@
// LoadMap() method.
// Place dynamically allocated heap buffer in symbol_data. Caller has the
// ownership of the buffer, and should call delete [] to free the buffer.
- static bool ReadSymbolFile(const string &file_name,
- char **symbol_data,
- size_t *symbol_data_size);
+ static bool ReadSymbolFile(const string& file_name,
+ char** symbol_data,
+ size_t* symbol_data_size);
protected:
// Users are not allowed create SourceLineResolverBase instance directly.
- SourceLineResolverBase(ModuleFactory *module_factory);
+ SourceLineResolverBase(ModuleFactory* module_factory);
virtual ~SourceLineResolverBase();
// Virtual methods inherited from SourceLineResolverInterface.
- virtual bool LoadModule(const CodeModule *module, const string &map_file);
- virtual bool LoadModuleUsingMapBuffer(const CodeModule *module,
- const string &map_buffer);
- virtual bool LoadModuleUsingMemoryBuffer(const CodeModule *module,
- char *memory_buffer,
+ virtual bool LoadModule(const CodeModule* module, const string& map_file);
+ virtual bool LoadModuleUsingMapBuffer(const CodeModule* module,
+ const string& map_buffer);
+ virtual bool LoadModuleUsingMemoryBuffer(const CodeModule* module,
+ char* memory_buffer,
size_t memory_buffer_size);
virtual bool ShouldDeleteMemoryBufferAfterLoadModule();
- virtual void UnloadModule(const CodeModule *module);
- virtual bool HasModule(const CodeModule *module);
- virtual bool IsModuleCorrupt(const CodeModule *module);
- virtual void FillSourceLineInfo(StackFrame *frame);
- virtual WindowsFrameInfo *FindWindowsFrameInfo(const StackFrame *frame);
- virtual CFIFrameInfo *FindCFIFrameInfo(const StackFrame *frame);
+ virtual void UnloadModule(const CodeModule* module);
+ virtual bool HasModule(const CodeModule* module);
+ virtual bool IsModuleCorrupt(const CodeModule* module);
+ virtual void FillSourceLineInfo(StackFrame* frame);
+ virtual WindowsFrameInfo* FindWindowsFrameInfo(const StackFrame* frame);
+ virtual CFIFrameInfo* FindCFIFrameInfo(const StackFrame* frame);
// Nested structs and classes.
struct Line;
struct Function;
struct PublicSymbol;
struct CompareString {
- bool operator()(const string &s1, const string &s2) const;
+ bool operator()(const string& s1, const string& s2) const;
};
// Module is an interface for an in-memory symbol file.
class Module;
@@ -101,18 +101,18 @@
// All of the modules that are loaded.
typedef map<string, Module*, CompareString> ModuleMap;
- ModuleMap *modules_;
+ ModuleMap* modules_;
// The loaded modules that were detecting to be corrupt during load.
typedef set<string, CompareString> ModuleSet;
- ModuleSet *corrupt_modules_;
+ ModuleSet* corrupt_modules_;
// All of heap-allocated buffers that are owned locally by resolver.
typedef std::map<string, char*, CompareString> MemoryMap;
- MemoryMap *memory_buffers_;
+ MemoryMap* memory_buffers_;
// Creates a concrete module at run-time.
- ModuleFactory *module_factory_;
+ ModuleFactory* module_factory_;
private:
// ModuleFactory needs to have access to protected type Module.
diff --git a/src/google_breakpad/processor/source_line_resolver_interface.h b/src/google_breakpad/processor/source_line_resolver_interface.h
index a694bf2..9901140 100644
--- a/src/google_breakpad/processor/source_line_resolver_interface.h
+++ b/src/google_breakpad/processor/source_line_resolver_interface.h
@@ -58,11 +58,11 @@
// and debug_identifier members populated.
//
// map_file should contain line/address mappings for this module.
- virtual bool LoadModule(const CodeModule *module,
- const string &map_file) = 0;
+ virtual bool LoadModule(const CodeModule* module,
+ const string& map_file) = 0;
// Same as above, but takes the contents of a pre-read map buffer
- virtual bool LoadModuleUsingMapBuffer(const CodeModule *module,
- const string &map_buffer) = 0;
+ virtual bool LoadModuleUsingMapBuffer(const CodeModule* module,
+ const string& map_buffer) = 0;
// Add an interface to load symbol using C-String data instead of string.
// This is useful in the optimization design for avoiding unnecessary copying
@@ -70,8 +70,8 @@
// LoadModuleUsingMemoryBuffer() does NOT take ownership of memory_buffer.
// LoadModuleUsingMemoryBuffer() null terminates the passed in buffer, if
// the last character is not a null terminator.
- virtual bool LoadModuleUsingMemoryBuffer(const CodeModule *module,
- char *memory_buffer,
+ virtual bool LoadModuleUsingMemoryBuffer(const CodeModule* module,
+ char* memory_buffer,
size_t memory_buffer_size) = 0;
// Return true if the memory buffer should be deleted immediately after
@@ -81,31 +81,31 @@
// Request that the specified module be unloaded from this resolver.
// A resolver may choose to ignore such a request.
- virtual void UnloadModule(const CodeModule *module) = 0;
+ virtual void UnloadModule(const CodeModule* module) = 0;
// Returns true if the module has been loaded.
- virtual bool HasModule(const CodeModule *module) = 0;
+ virtual bool HasModule(const CodeModule* module) = 0;
// Returns true if the module has been loaded and it is corrupt.
- virtual bool IsModuleCorrupt(const CodeModule *module) = 0;
+ virtual bool IsModuleCorrupt(const CodeModule* module) = 0;
// Fills in the function_base, function_name, source_file_name,
// and source_line fields of the StackFrame. The instruction and
// module_name fields must already be filled in.
- virtual void FillSourceLineInfo(StackFrame *frame) = 0;
+ virtual void FillSourceLineInfo(StackFrame* frame) = 0;
// If Windows stack walking information is available covering
// FRAME's instruction address, return a WindowsFrameInfo structure
// describing it. If the information is not available, returns NULL.
// A NULL return value does not indicate an error. The caller takes
// ownership of any returned WindowsFrameInfo object.
- virtual WindowsFrameInfo *FindWindowsFrameInfo(const StackFrame *frame) = 0;
+ virtual WindowsFrameInfo* FindWindowsFrameInfo(const StackFrame* frame) = 0;
// If CFI stack walking information is available covering ADDRESS,
// return a CFIFrameInfo structure describing it. If the information
// is not available, return NULL. The caller takes ownership of any
// returned CFIFrameInfo object.
- virtual CFIFrameInfo *FindCFIFrameInfo(const StackFrame *frame) = 0;
+ virtual CFIFrameInfo* FindCFIFrameInfo(const StackFrame* frame) = 0;
protected:
// SourceLineResolverInterface cannot be instantiated except by subclasses
diff --git a/src/google_breakpad/processor/symbol_supplier.h b/src/google_breakpad/processor/symbol_supplier.h
index a042081..6ec0176 100644
--- a/src/google_breakpad/processor/symbol_supplier.h
+++ b/src/google_breakpad/processor/symbol_supplier.h
@@ -63,35 +63,35 @@
// to help locate the symbol file. system_info may be NULL or its
// fields may be empty if these values are unknown. symbol_file
// must be a pointer to a valid string
- virtual SymbolResult GetSymbolFile(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file) = 0;
+ virtual SymbolResult GetSymbolFile(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file) = 0;
// Same as above, except also places symbol data into symbol_data.
// If symbol_data is NULL, the data is not returned.
// TODO(nealsid) Once we have symbol data caching behavior implemented
// investigate making all symbol suppliers implement all methods,
// and make this pure virtual
- virtual SymbolResult GetSymbolFile(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file,
- string *symbol_data) = 0;
+ virtual SymbolResult GetSymbolFile(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file,
+ string* symbol_data) = 0;
// Same as above, except allocates data buffer on heap and then places the
// symbol data into the buffer as C-string.
// SymbolSupplier is responsible for deleting the data buffer. After the call
// to GetCStringSymbolData(), the caller should call FreeSymbolData(const
- // Module *module) once the data buffer is no longer needed.
+ // Module* module) once the data buffer is no longer needed.
// If symbol_data is not NULL, symbol supplier won't return FOUND unless it
// returns a valid buffer in symbol_data, e.g., returns INTERRUPT on memory
// allocation failure.
- virtual SymbolResult GetCStringSymbolData(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file,
- char **symbol_data,
- size_t *symbol_data_size) = 0;
+ virtual SymbolResult GetCStringSymbolData(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file,
+ char** symbol_data,
+ size_t* symbol_data_size) = 0;
// Frees the data buffer allocated for the module in GetCStringSymbolData.
- virtual void FreeSymbolData(const CodeModule *module) = 0;
+ virtual void FreeSymbolData(const CodeModule* module) = 0;
};
} // namespace google_breakpad
diff --git a/src/processor/address_map-inl.h b/src/processor/address_map-inl.h
index 251c447..96d955a 100644
--- a/src/processor/address_map-inl.h
+++ b/src/processor/address_map-inl.h
@@ -45,8 +45,8 @@
namespace google_breakpad {
template<typename AddressType, typename EntryType>
-bool AddressMap<AddressType, EntryType>::Store(const AddressType &address,
- const EntryType &entry) {
+bool AddressMap<AddressType, EntryType>::Store(const AddressType& address,
+ const EntryType& entry) {
// Ensure that the specified address doesn't conflict with something already
// in the map.
if (map_.find(address) != map_.end()) {
@@ -61,8 +61,8 @@
template<typename AddressType, typename EntryType>
bool AddressMap<AddressType, EntryType>::Retrieve(
- const AddressType &address,
- EntryType *entry, AddressType *entry_address) const {
+ const AddressType& address,
+ EntryType* entry, AddressType* entry_address) const {
BPLOG_IF(ERROR, !entry) << "AddressMap::Retrieve requires |entry|";
assert(entry);
diff --git a/src/processor/address_map.h b/src/processor/address_map.h
index 2972cbb..87321a7 100644
--- a/src/processor/address_map.h
+++ b/src/processor/address_map.h
@@ -53,15 +53,15 @@
// Inserts an entry into the map. Returns false without storing the entry
// if an entry is already stored in the map at the same address as specified
// by the address argument.
- bool Store(const AddressType &address, const EntryType &entry);
+ bool Store(const AddressType& address, const EntryType& entry);
// Locates the entry stored at the highest address less than or equal to
// the address argument. If there is no such range, returns false. The
// entry is returned in entry, which is a required argument. If
// entry_address is not NULL, it will be set to the address that the entry
// was stored at.
- bool Retrieve(const AddressType &address,
- EntryType *entry, AddressType *entry_address) const;
+ bool Retrieve(const AddressType& address,
+ EntryType* entry, AddressType* entry_address) const;
// Empties the address map, restoring it to the same state as when it was
// initially created.
diff --git a/src/processor/address_map_unittest.cc b/src/processor/address_map_unittest.cc
index 9b4095b..7c85f5e 100644
--- a/src/processor/address_map_unittest.cc
+++ b/src/processor/address_map_unittest.cc
@@ -189,7 +189,7 @@
} // namespace
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
BPLOG_INIT(&argc, &argv);
return RunTests() ? 0 : 1;
diff --git a/src/processor/basic_code_module.h b/src/processor/basic_code_module.h
index 35d66a6..7527289 100644
--- a/src/processor/basic_code_module.h
+++ b/src/processor/basic_code_module.h
@@ -66,11 +66,11 @@
is_unloaded_(that->is_unloaded()) {}
BasicCodeModule(uint64_t base_address, uint64_t size,
- const string &code_file,
- const string &code_identifier,
- const string &debug_file,
- const string &debug_identifier,
- const string &version,
+ const string& code_file,
+ const string& code_identifier,
+ const string& debug_file,
+ const string& debug_identifier,
+ const string& version,
const bool is_unloaded = false)
: base_address_(base_address),
size_(size),
@@ -112,8 +112,8 @@
bool is_unloaded_;
// Disallow copy constructor and assignment operator.
- BasicCodeModule(const BasicCodeModule &that);
- void operator=(const BasicCodeModule &that);
+ BasicCodeModule(const BasicCodeModule& that);
+ void operator=(const BasicCodeModule& that);
};
} // namespace google_breakpad
diff --git a/src/processor/basic_code_modules.h b/src/processor/basic_code_modules.h
index 45ebc53..8c26abb 100644
--- a/src/processor/basic_code_modules.h
+++ b/src/processor/basic_code_modules.h
@@ -88,8 +88,8 @@
private:
// Disallow copy constructor and assignment operator.
- BasicCodeModules(const BasicCodeModules &that);
- void operator=(const BasicCodeModules &that);
+ BasicCodeModules(const BasicCodeModules& that);
+ void operator=(const BasicCodeModules& that);
};
} // namespace google_breakpad
diff --git a/src/processor/basic_source_line_resolver.cc b/src/processor/basic_source_line_resolver.cc
index c4aa949..64d4001 100644
--- a/src/processor/basic_source_line_resolver.cc
+++ b/src/processor/basic_source_line_resolver.cc
@@ -69,11 +69,11 @@
// field, and max_tokens is the maximum number of tokens including the optional
// field. Refer to the documentation for Tokenize for descriptions of the other
// arguments.
-bool TokenizeWithOptionalField(char *line,
- const char *optional_field,
- const char *separators,
+bool TokenizeWithOptionalField(char* line,
+ const char* optional_field,
+ const char* separators,
int max_tokens,
- vector<char*> *tokens) {
+ vector<char*>* tokens) {
// First tokenize assuming the optional field is not present. If we then see
// the optional field, additionally tokenize the last token into two tokens.
if (!Tokenize(line, separators, max_tokens - 1, tokens)) {
@@ -98,7 +98,7 @@
} // namespace
-static const char *kWhitespace = " \r\n";
+static const char* kWhitespace = " \r\n";
static const int kMaxErrorsPrinted = 5;
static const int kMaxErrorsBeforeBailing = 100;
@@ -107,9 +107,9 @@
// static
void BasicSourceLineResolver::Module::LogParseError(
- const string &message,
+ const string& message,
int line_number,
- int *num_errors) {
+ int* num_errors) {
if (++(*num_errors) <= kMaxErrorsPrinted) {
if (line_number > 0) {
BPLOG(ERROR) << "Line " << line_number << ": " << message;
@@ -120,12 +120,12 @@
}
bool BasicSourceLineResolver::Module::LoadMapFromMemory(
- char *memory_buffer,
+ char* memory_buffer,
size_t memory_buffer_size) {
linked_ptr<Function> cur_func;
int line_number = 0;
int num_errors = 0;
- char *save_ptr;
+ char* save_ptr;
// If the length is 0, we can still pretend we have a symbol file. This is
// for scenarios that want to test symbol lookup, but don't necessarily care
@@ -160,7 +160,7 @@
&num_errors);
}
- char *buffer;
+ char* buffer;
buffer = strtok_r(memory_buffer, "\r\n", &save_ptr);
while (buffer != NULL) {
@@ -207,7 +207,7 @@
LogParseError("Found source line data without a function",
line_number, &num_errors);
} else {
- Line *line = ParseLine(buffer);
+ Line* line = ParseLine(buffer);
if (!line) {
LogParseError("ParseLine failed", line_number, &num_errors);
} else {
@@ -225,7 +225,7 @@
return true;
}
-void BasicSourceLineResolver::Module::LookupAddress(StackFrame *frame) const {
+void BasicSourceLineResolver::Module::LookupAddress(StackFrame* frame) const {
MemAddr address = frame->instruction - frame->module->base_address();
// First, look for a FUNC record that covers address. Use
@@ -264,8 +264,8 @@
}
}
-WindowsFrameInfo *BasicSourceLineResolver::Module::FindWindowsFrameInfo(
- const StackFrame *frame) const {
+WindowsFrameInfo* BasicSourceLineResolver::Module::FindWindowsFrameInfo(
+ const StackFrame* frame) const {
MemAddr address = frame->instruction - frame->module->base_address();
scoped_ptr<WindowsFrameInfo> result(new WindowsFrameInfo());
@@ -313,8 +313,8 @@
return NULL;
}
-CFIFrameInfo *BasicSourceLineResolver::Module::FindCFIFrameInfo(
- const StackFrame *frame) const {
+CFIFrameInfo* BasicSourceLineResolver::Module::FindCFIFrameInfo(
+ const StackFrame* frame) const {
MemAddr address = frame->instruction - frame->module->base_address();
MemAddr initial_base, initial_size;
string initial_rules;
@@ -347,9 +347,9 @@
return rules.release();
}
-bool BasicSourceLineResolver::Module::ParseFile(char *file_line) {
+bool BasicSourceLineResolver::Module::ParseFile(char* file_line) {
long index;
- char *filename;
+ char* filename;
if (SymbolParseHelper::ParseFile(file_line, &index, &filename)) {
files_.insert(make_pair(index, string(filename)));
return true;
@@ -358,12 +358,12 @@
}
BasicSourceLineResolver::Function*
-BasicSourceLineResolver::Module::ParseFunction(char *function_line) {
+BasicSourceLineResolver::Module::ParseFunction(char* function_line) {
bool is_multiple;
uint64_t address;
uint64_t size;
long stack_param_size;
- char *name;
+ char* name;
if (SymbolParseHelper::ParseFunction(function_line, &is_multiple, &address,
&size, &stack_param_size, &name)) {
return new Function(name, address, size, stack_param_size, is_multiple);
@@ -372,7 +372,7 @@
}
BasicSourceLineResolver::Line* BasicSourceLineResolver::Module::ParseLine(
- char *line_line) {
+ char* line_line) {
uint64_t address;
uint64_t size;
long line_number;
@@ -385,11 +385,11 @@
return NULL;
}
-bool BasicSourceLineResolver::Module::ParsePublicSymbol(char *public_line) {
+bool BasicSourceLineResolver::Module::ParsePublicSymbol(char* public_line) {
bool is_multiple;
uint64_t address;
long stack_param_size;
- char *name;
+ char* name;
if (SymbolParseHelper::ParsePublicSymbol(public_line, &is_multiple, &address,
&stack_param_size, &name)) {
@@ -411,7 +411,7 @@
return false;
}
-bool BasicSourceLineResolver::Module::ParseStackInfo(char *stack_info_line) {
+bool BasicSourceLineResolver::Module::ParseStackInfo(char* stack_info_line) {
// Skip "STACK " prefix.
stack_info_line += 6;
@@ -419,7 +419,7 @@
// information this is.
while (*stack_info_line == ' ')
stack_info_line++;
- const char *platform = stack_info_line;
+ const char* platform = stack_info_line;
while (!strchr(kWhitespace, *stack_info_line))
stack_info_line++;
*stack_info_line++ = '\0';
@@ -468,23 +468,23 @@
}
bool BasicSourceLineResolver::Module::ParseCFIFrameInfo(
- char *stack_info_line) {
- char *cursor;
+ char* stack_info_line) {
+ char* cursor;
// Is this an INIT record or a delta record?
- char *init_or_address = strtok_r(stack_info_line, " \r\n", &cursor);
+ char* init_or_address = strtok_r(stack_info_line, " \r\n", &cursor);
if (!init_or_address)
return false;
if (strcmp(init_or_address, "INIT") == 0) {
// This record has the form "STACK INIT <address> <size> <rules...>".
- char *address_field = strtok_r(NULL, " \r\n", &cursor);
+ char* address_field = strtok_r(NULL, " \r\n", &cursor);
if (!address_field) return false;
- char *size_field = strtok_r(NULL, " \r\n", &cursor);
+ char* size_field = strtok_r(NULL, " \r\n", &cursor);
if (!size_field) return false;
- char *initial_rules = strtok_r(NULL, "\r\n", &cursor);
+ char* initial_rules = strtok_r(NULL, "\r\n", &cursor);
if (!initial_rules) return false;
MemAddr address = strtoul(address_field, NULL, 16);
@@ -494,8 +494,8 @@
}
// This record has the form "STACK <address> <rules...>".
- char *address_field = init_or_address;
- char *delta_rules = strtok_r(NULL, "\r\n", &cursor);
+ char* address_field = init_or_address;
+ char* delta_rules = strtok_r(NULL, "\r\n", &cursor);
if (!delta_rules) return false;
MemAddr address = strtoul(address_field, NULL, 16);
cfi_delta_rules_[address] = delta_rules;
@@ -503,8 +503,8 @@
}
// static
-bool SymbolParseHelper::ParseFile(char *file_line, long *index,
- char **filename) {
+bool SymbolParseHelper::ParseFile(char* file_line, long* index,
+ char** filename) {
// FILE <id> <filename>
assert(strncmp(file_line, "FILE ", 5) == 0);
file_line += 5; // skip prefix
@@ -514,7 +514,7 @@
return false;
}
- char *after_number;
+ char* after_number;
*index = strtol(tokens[0], &after_number, 10);
if (!IsValidAfterNumber(after_number) || *index < 0 ||
*index == std::numeric_limits<long>::max()) {
@@ -530,9 +530,9 @@
}
// static
-bool SymbolParseHelper::ParseFunction(char *function_line, bool *is_multiple,
- uint64_t *address, uint64_t *size,
- long *stack_param_size, char **name) {
+bool SymbolParseHelper::ParseFunction(char* function_line, bool* is_multiple,
+ uint64_t* address, uint64_t* size,
+ long* stack_param_size, char** name) {
// FUNC [<multiple>] <address> <size> <stack_param_size> <name>
assert(strncmp(function_line, "FUNC ", 5) == 0);
function_line += 5; // skip prefix
@@ -545,7 +545,7 @@
*is_multiple = strcmp(tokens[0], "m") == 0;
int next_token = *is_multiple ? 1 : 0;
- char *after_number;
+ char* after_number;
*address = strtoull(tokens[next_token++], &after_number, 16);
if (!IsValidAfterNumber(after_number) ||
*address == std::numeric_limits<unsigned long long>::max()) {
@@ -568,16 +568,16 @@
}
// static
-bool SymbolParseHelper::ParseLine(char *line_line, uint64_t *address,
- uint64_t *size, long *line_number,
- long *source_file) {
+bool SymbolParseHelper::ParseLine(char* line_line, uint64_t* address,
+ uint64_t* size, long* line_number,
+ long* source_file) {
// <address> <size> <line number> <source file id>
vector<char*> tokens;
if (!Tokenize(line_line, kWhitespace, 4, &tokens)) {
return false;
}
- char *after_number;
+ char* after_number;
*address = strtoull(tokens[0], &after_number, 16);
if (!IsValidAfterNumber(after_number) ||
*address == std::numeric_limits<unsigned long long>::max()) {
@@ -613,10 +613,10 @@
}
// static
-bool SymbolParseHelper::ParsePublicSymbol(char *public_line, bool *is_multiple,
- uint64_t *address,
- long *stack_param_size,
- char **name) {
+bool SymbolParseHelper::ParsePublicSymbol(char* public_line, bool* is_multiple,
+ uint64_t* address,
+ long* stack_param_size,
+ char** name) {
// PUBLIC [<multiple>] <address> <stack_param_size> <name>
assert(strncmp(public_line, "PUBLIC ", 7) == 0);
public_line += 7; // skip prefix
@@ -629,7 +629,7 @@
*is_multiple = strcmp(tokens[0], "m") == 0;
int next_token = *is_multiple ? 1 : 0;
- char *after_number;
+ char* after_number;
*address = strtoull(tokens[next_token++], &after_number, 16);
if (!IsValidAfterNumber(after_number) ||
*address == std::numeric_limits<unsigned long long>::max()) {
@@ -647,7 +647,7 @@
}
// static
-bool SymbolParseHelper::IsValidAfterNumber(char *after_number) {
+bool SymbolParseHelper::IsValidAfterNumber(char* after_number) {
if (after_number != NULL && strchr(kWhitespace, *after_number) != NULL) {
return true;
}
diff --git a/src/processor/basic_source_line_resolver_types.h b/src/processor/basic_source_line_resolver_types.h
index 89eb57e..c103040 100644
--- a/src/processor/basic_source_line_resolver_types.h
+++ b/src/processor/basic_source_line_resolver_types.h
@@ -57,7 +57,7 @@
struct
BasicSourceLineResolver::Function : public SourceLineResolverBase::Function {
- Function(const string &function_name,
+ Function(const string& function_name,
MemAddr function_address,
MemAddr code_size,
int set_parameter_size,
@@ -75,7 +75,7 @@
class BasicSourceLineResolver::Module : public SourceLineResolverBase::Module {
public:
- explicit Module(const string &name) : name_(name), is_corrupt_(false) { }
+ explicit Module(const string& name) : name_(name), is_corrupt_(false) { }
virtual ~Module() { }
// Loads a map from the given buffer in char* type.
@@ -83,7 +83,7 @@
// The passed in |memory buffer| is of size |memory_buffer_size|. If it is
// not null terminated, LoadMapFromMemory() will null terminate it by
// modifying the passed in buffer.
- virtual bool LoadMapFromMemory(char *memory_buffer,
+ virtual bool LoadMapFromMemory(char* memory_buffer,
size_t memory_buffer_size);
// Tells whether the loaded symbol data is corrupt. Return value is
@@ -92,20 +92,20 @@
// Looks up the given relative address, and fills the StackFrame struct
// with the result.
- virtual void LookupAddress(StackFrame *frame) const;
+ virtual void LookupAddress(StackFrame* frame) const;
// If Windows stack walking information is available covering ADDRESS,
// return a WindowsFrameInfo structure describing it. If the information
// is not available, returns NULL. A NULL return value does not indicate
// an error. The caller takes ownership of any returned WindowsFrameInfo
// object.
- virtual WindowsFrameInfo *FindWindowsFrameInfo(const StackFrame *frame) const;
+ virtual WindowsFrameInfo* FindWindowsFrameInfo(const StackFrame* frame) const;
// If CFI stack walking information is available covering ADDRESS,
// return a CFIFrameInfo structure describing it. If the information
// is not available, return NULL. The caller takes ownership of any
// returned CFIFrameInfo object.
- virtual CFIFrameInfo *FindCFIFrameInfo(const StackFrame *frame) const;
+ virtual CFIFrameInfo* FindCFIFrameInfo(const StackFrame* frame) const;
private:
// Friend declarations.
@@ -118,29 +118,29 @@
// Logs parse errors. |*num_errors| is increased every time LogParseError is
// called.
static void LogParseError(
- const string &message,
+ const string& message,
int line_number,
- int *num_errors);
+ int* num_errors);
// Parses a file declaration
- bool ParseFile(char *file_line);
+ bool ParseFile(char* file_line);
// Parses a function declaration, returning a new Function object.
- Function* ParseFunction(char *function_line);
+ Function* ParseFunction(char* function_line);
// Parses a line declaration, returning a new Line object.
- Line* ParseLine(char *line_line);
+ Line* ParseLine(char* line_line);
// Parses a PUBLIC symbol declaration, storing it in public_symbols_.
// Returns false if an error occurs.
- bool ParsePublicSymbol(char *public_line);
+ bool ParsePublicSymbol(char* public_line);
// Parses a STACK WIN or STACK CFI frame info declaration, storing
// it in the appropriate table.
- bool ParseStackInfo(char *stack_info_line);
+ bool ParseStackInfo(char* stack_info_line);
// Parses a STACK CFI record, storing it in cfi_frame_info_.
- bool ParseCFIFrameInfo(char *stack_info_line);
+ bool ParseCFIFrameInfo(char* stack_info_line);
string name_;
FileMap files_;
diff --git a/src/processor/basic_source_line_resolver_unittest.cc b/src/processor/basic_source_line_resolver_unittest.cc
index 90c3417..2cb2967 100644
--- a/src/processor/basic_source_line_resolver_unittest.cc
+++ b/src/processor/basic_source_line_resolver_unittest.cc
@@ -83,15 +83,15 @@
class MockMemoryRegion: public MemoryRegion {
uint64_t GetBase() const { return 0x10000; }
uint32_t GetSize() const { return 0x01000; }
- bool GetMemoryAtAddress(uint64_t address, uint8_t *value) const {
+ bool GetMemoryAtAddress(uint64_t address, uint8_t* value) const {
*value = address & 0xff;
return true;
}
- bool GetMemoryAtAddress(uint64_t address, uint16_t *value) const {
+ bool GetMemoryAtAddress(uint64_t address, uint16_t* value) const {
*value = address & 0xffff;
return true;
}
- bool GetMemoryAtAddress(uint64_t address, uint32_t *value) const {
+ bool GetMemoryAtAddress(uint64_t address, uint32_t* value) const {
switch (address) {
case 0x10008: *value = 0x98ecadc3; break; // saved %ebx
case 0x1000c: *value = 0x878f7524; break; // saved %esi
@@ -102,7 +102,7 @@
}
return true;
}
- bool GetMemoryAtAddress(uint64_t address, uint64_t *value) const {
+ bool GetMemoryAtAddress(uint64_t address, uint64_t* value) const {
*value = address;
return true;
}
@@ -116,9 +116,9 @@
// EXPECTED's.) Also verify that ACTUAL has associations for ".ra" and
// ".cfa".
static bool VerifyRegisters(
- const char *file, int line,
- const CFIFrameInfo::RegisterValueMap<uint32_t> &expected,
- const CFIFrameInfo::RegisterValueMap<uint32_t> &actual) {
+ const char* file, int line,
+ const CFIFrameInfo::RegisterValueMap<uint32_t>& expected,
+ const CFIFrameInfo::RegisterValueMap<uint32_t>& actual) {
CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator a;
a = actual.find(".cfa");
if (a == actual.end())
@@ -148,7 +148,7 @@
}
-static bool VerifyEmpty(const StackFrame &frame) {
+static bool VerifyEmpty(const StackFrame& frame) {
if (frame.function_name.empty() &&
frame.source_file_name.empty() &&
frame.source_line == 0)
@@ -156,7 +156,7 @@
return false;
}
-static void ClearSourceLineInfo(StackFrame *frame) {
+static void ClearSourceLineInfo(StackFrame* frame) {
frame->function_name.clear();
frame->module = NULL;
frame->source_file_name.clear();
@@ -417,7 +417,7 @@
// FILE <id> <filename>
TEST(SymbolParseHelper, ParseFileValid) {
long index;
- char *filename;
+ char* filename;
char kTestLine[] = "FILE 1 file name";
ASSERT_TRUE(SymbolParseHelper::ParseFile(kTestLine, &index, &filename));
@@ -435,7 +435,7 @@
// FILE <id> <filename>
TEST(SymbolParseHelper, ParseFileInvalid) {
long index;
- char *filename;
+ char* filename;
// Test missing file name.
char kTestLine[] = "FILE 1 ";
@@ -461,7 +461,7 @@
uint64_t address;
uint64_t size;
long stack_param_size;
- char *name;
+ char* name;
char kTestLine[] = "FUNC 1 2 3 function name";
ASSERT_TRUE(SymbolParseHelper::ParseFunction(kTestLine, &multiple, &address,
@@ -513,7 +513,7 @@
uint64_t address;
uint64_t size;
long stack_param_size;
- char *name;
+ char* name;
// Test missing function name.
char kTestLine[] = "FUNC 1 2 3 ";
@@ -649,7 +649,7 @@
bool multiple;
uint64_t address;
long stack_param_size;
- char *name;
+ char* name;
char kTestLine[] = "PUBLIC 1 2 3";
ASSERT_TRUE(SymbolParseHelper::ParsePublicSymbol(kTestLine, &multiple,
@@ -697,7 +697,7 @@
bool multiple;
uint64_t address;
long stack_param_size;
- char *name;
+ char* name;
// Test missing source function name.
char kTestLine[] = "PUBLIC 1 2 ";
@@ -738,7 +738,7 @@
} // namespace
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
diff --git a/src/processor/call_stack.cc b/src/processor/call_stack.cc
index 925f084..f219e84 100644
--- a/src/processor/call_stack.cc
+++ b/src/processor/call_stack.cc
@@ -43,7 +43,7 @@
}
void CallStack::Clear() {
- for (vector<StackFrame *>::const_iterator iterator = frames_.begin();
+ for (vector<StackFrame*>::const_iterator iterator = frames_.begin();
iterator != frames_.end();
++iterator) {
delete *iterator;
diff --git a/src/processor/cfi_frame_info-inl.h b/src/processor/cfi_frame_info-inl.h
index 7e7af0a..52d2f5f 100644
--- a/src/processor/cfi_frame_info-inl.h
+++ b/src/processor/cfi_frame_info-inl.h
@@ -42,12 +42,12 @@
template <typename RegisterType, class RawContextType>
bool SimpleCFIWalker<RegisterType, RawContextType>::FindCallerRegisters(
- const MemoryRegion &memory,
- const CFIFrameInfo &cfi_frame_info,
- const RawContextType &callee_context,
+ const MemoryRegion& memory,
+ const CFIFrameInfo& cfi_frame_info,
+ const RawContextType& callee_context,
int callee_validity,
- RawContextType *caller_context,
- int *caller_validity) const {
+ RawContextType* caller_context,
+ int* caller_validity) const {
typedef CFIFrameInfo::RegisterValueMap<RegisterType> ValueMap;
ValueMap callee_registers;
ValueMap caller_registers;
@@ -56,7 +56,7 @@
// Populate callee_registers with register values from callee_context.
for (size_t i = 0; i < map_size_; i++) {
- const RegisterSet &r = register_map_[i];
+ const RegisterSet& r = register_map_[i];
if (callee_validity & r.validity_flag)
callee_registers[r.name] = callee_context.*r.context_member;
}
@@ -71,7 +71,7 @@
memset(caller_context, 0xda, sizeof(*caller_context));
*caller_validity = 0;
for (size_t i = 0; i < map_size_; i++) {
- const RegisterSet &r = register_map_[i];
+ const RegisterSet& r = register_map_[i];
typename ValueMap::const_iterator caller_entry;
// Did the rules provide a value for this register by its name?
diff --git a/src/processor/cfi_frame_info.cc b/src/processor/cfi_frame_info.cc
index 0c4af7b..280620f 100644
--- a/src/processor/cfi_frame_info.cc
+++ b/src/processor/cfi_frame_info.cc
@@ -48,9 +48,9 @@
#endif
template<typename V>
-bool CFIFrameInfo::FindCallerRegs(const RegisterValueMap<V> ®isters,
- const MemoryRegion &memory,
- RegisterValueMap<V> *caller_registers) const {
+bool CFIFrameInfo::FindCallerRegs(const RegisterValueMap<V>& registers,
+ const MemoryRegion& memory,
+ RegisterValueMap<V>* caller_registers) const {
// If there are not rules for both .ra and .cfa in effect at this address,
// don't use this CFI data for stack walking.
if (cfa_rule_.empty() || ra_rule_.empty())
@@ -93,13 +93,13 @@
// Explicit instantiations for 32-bit and 64-bit architectures.
template bool CFIFrameInfo::FindCallerRegs<uint32_t>(
- const RegisterValueMap<uint32_t> ®isters,
- const MemoryRegion &memory,
- RegisterValueMap<uint32_t> *caller_registers) const;
+ const RegisterValueMap<uint32_t>& registers,
+ const MemoryRegion& memory,
+ RegisterValueMap<uint32_t>* caller_registers) const;
template bool CFIFrameInfo::FindCallerRegs<uint64_t>(
- const RegisterValueMap<uint64_t> ®isters,
- const MemoryRegion &memory,
- RegisterValueMap<uint64_t> *caller_registers) const;
+ const RegisterValueMap<uint64_t>& registers,
+ const MemoryRegion& memory,
+ RegisterValueMap<uint64_t>* caller_registers) const;
string CFIFrameInfo::Serialize() const {
std::ostringstream stream;
@@ -123,7 +123,7 @@
return stream.str();
}
-bool CFIRuleParser::Parse(const string &rule_set) {
+bool CFIRuleParser::Parse(const string& rule_set) {
size_t rule_set_len = rule_set.size();
scoped_array<char> working_copy(new char[rule_set_len + 1]);
memcpy(working_copy.get(), rule_set.data(), rule_set_len);
@@ -132,9 +132,9 @@
name_.clear();
expression_.clear();
- char *cursor;
+ char* cursor;
static const char token_breaks[] = " \t\r\n";
- char *token = strtok_r(working_copy.get(), token_breaks, &cursor);
+ char* token = strtok_r(working_copy.get(), token_breaks, &cursor);
for (;;) {
// End of rule set?
@@ -170,16 +170,16 @@
return true;
}
-void CFIFrameInfoParseHandler::CFARule(const string &expression) {
+void CFIFrameInfoParseHandler::CFARule(const string& expression) {
frame_info_->SetCFARule(expression);
}
-void CFIFrameInfoParseHandler::RARule(const string &expression) {
+void CFIFrameInfoParseHandler::RARule(const string& expression) {
frame_info_->SetRARule(expression);
}
-void CFIFrameInfoParseHandler::RegisterRule(const string &name,
- const string &expression) {
+void CFIFrameInfoParseHandler::RegisterRule(const string& name,
+ const string& expression) {
frame_info_->SetRegisterRule(name, expression);
}
diff --git a/src/processor/cfi_frame_info.h b/src/processor/cfi_frame_info.h
index 90a1b3d..2bc9333 100644
--- a/src/processor/cfi_frame_info.h
+++ b/src/processor/cfi_frame_info.h
@@ -72,9 +72,9 @@
// Set the expression for computing a call frame address, return
// address, or register's value. At least the CFA rule and the RA
// rule must be set before calling FindCallerRegs.
- void SetCFARule(const string &expression) { cfa_rule_ = expression; }
- void SetRARule(const string &expression) { ra_rule_ = expression; }
- void SetRegisterRule(const string ®ister_name, const string &expression) {
+ void SetCFARule(const string& expression) { cfa_rule_ = expression; }
+ void SetRARule(const string& expression) { ra_rule_ = expression; }
+ void SetRegisterRule(const string& register_name, const string& expression) {
register_rules_[register_name] = expression;
}
@@ -96,9 +96,9 @@
// These may be helpful in computing the caller's PC and stack
// pointer, if their values are not explicitly specified.
template<typename ValueType>
- bool FindCallerRegs(const RegisterValueMap<ValueType> ®isters,
- const MemoryRegion &memory,
- RegisterValueMap<ValueType> *caller_registers) const;
+ bool FindCallerRegs(const RegisterValueMap<ValueType>& registers,
+ const MemoryRegion& memory,
+ RegisterValueMap<ValueType>* caller_registers) const;
// Serialize the rules in this object into a string in the format
// of STACK CFI records.
@@ -148,28 +148,28 @@
virtual ~Handler() { }
// The input specifies EXPRESSION as the CFA/RA computation rule.
- virtual void CFARule(const string &expression) = 0;
- virtual void RARule(const string &expression) = 0;
+ virtual void CFARule(const string& expression) = 0;
+ virtual void RARule(const string& expression) = 0;
// The input specifies EXPRESSION as the recovery rule for register NAME.
- virtual void RegisterRule(const string &name, const string &expression) = 0;
+ virtual void RegisterRule(const string& name, const string& expression) = 0;
};
// Construct a parser which feeds its results to HANDLER.
- CFIRuleParser(Handler *handler) : handler_(handler) { }
+ CFIRuleParser(Handler* handler) : handler_(handler) { }
// Parse RULE_SET as a set of CFA computation and RA/register
// recovery rules, as appearing in STACK CFI records. Report the
// results of parsing by making the appropriate calls to handler_.
// Return true if parsing was successful, false otherwise.
- bool Parse(const string &rule_set);
+ bool Parse(const string& rule_set);
private:
// Report any accumulated rule to handler_
bool Report();
// The handler to which the parser reports its findings.
- Handler *handler_;
+ Handler* handler_;
// Working data.
string name_, expression_;
@@ -180,15 +180,15 @@
class CFIFrameInfoParseHandler: public CFIRuleParser::Handler {
public:
// Populate FRAME_INFO with the results of parsing.
- CFIFrameInfoParseHandler(CFIFrameInfo *frame_info)
+ CFIFrameInfoParseHandler(CFIFrameInfo* frame_info)
: frame_info_(frame_info) { }
- void CFARule(const string &expression);
- void RARule(const string &expression);
- void RegisterRule(const string &name, const string &expression);
+ void CFARule(const string& expression);
+ void RARule(const string& expression);
+ void RegisterRule(const string& name, const string& expression);
private:
- CFIFrameInfo *frame_info_;
+ CFIFrameInfo* frame_info_;
};
// A utility class template for simple 'STACK CFI'-driven stack walkers.
@@ -212,14 +212,14 @@
// A structure describing one architecture register.
struct RegisterSet {
// The register name, as it appears in STACK CFI rules.
- const char *name;
+ const char* name;
// An alternate name that the register's value might be found
// under in a register value dictionary, or NULL. When generating
// names, prefer NAME to this value. It's common to list ".cfa" as
// an alternative name for the stack pointer, and ".ra" as an
// alternative name for the instruction pointer.
- const char *alternate_name;
+ const char* alternate_name;
// True if the callee is expected to preserve the value of this
// register. If this flag is true for some register R, and the STACK
@@ -240,7 +240,7 @@
// architecture's register set. REGISTER_MAP is an array of
// RegisterSet structures; MAP_SIZE is the number of elements in the
// array.
- SimpleCFIWalker(const RegisterSet *register_map, size_t map_size)
+ SimpleCFIWalker(const RegisterSet* register_map, size_t map_size)
: register_map_(register_map), map_size_(map_size) { }
// Compute the calling frame's raw context given the callee's raw
@@ -256,15 +256,15 @@
// fill in CALLER_CONTEXT with the caller's register values, and set
// CALLER_VALIDITY to indicate which registers are valid in
// CALLER_CONTEXT. Return true on success, or false on failure.
- bool FindCallerRegisters(const MemoryRegion &memory,
- const CFIFrameInfo &cfi_frame_info,
- const RawContextType &callee_context,
+ bool FindCallerRegisters(const MemoryRegion& memory,
+ const CFIFrameInfo& cfi_frame_info,
+ const RawContextType& callee_context,
int callee_validity,
- RawContextType *caller_context,
- int *caller_validity) const;
+ RawContextType* caller_context,
+ int* caller_validity) const;
private:
- const RegisterSet *register_map_;
+ const RegisterSet* register_map_;
size_t map_size_;
};
diff --git a/src/processor/cfi_frame_info_unittest.cc b/src/processor/cfi_frame_info_unittest.cc
index 542b284..8111437 100644
--- a/src/processor/cfi_frame_info_unittest.cc
+++ b/src/processor/cfi_frame_info_unittest.cc
@@ -56,10 +56,10 @@
public:
MOCK_CONST_METHOD0(GetBase, uint64_t());
MOCK_CONST_METHOD0(GetSize, uint32_t());
- MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(uint64_t, uint8_t *));
- MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(uint64_t, uint16_t *));
- MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(uint64_t, uint32_t *));
- MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(uint64_t, uint64_t *));
+ MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(uint64_t, uint8_t*));
+ MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(uint64_t, uint16_t*));
+ MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(uint64_t, uint32_t*));
+ MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(uint64_t, uint64_t*));
MOCK_CONST_METHOD0(Print, void());
};
@@ -70,10 +70,10 @@
void ExpectNoMemoryReferences() {
EXPECT_CALL(memory, GetBase()).Times(0);
EXPECT_CALL(memory, GetSize()).Times(0);
- EXPECT_CALL(memory, GetMemoryAtAddress(_, A<uint8_t *>())).Times(0);
- EXPECT_CALL(memory, GetMemoryAtAddress(_, A<uint16_t *>())).Times(0);
- EXPECT_CALL(memory, GetMemoryAtAddress(_, A<uint32_t *>())).Times(0);
- EXPECT_CALL(memory, GetMemoryAtAddress(_, A<uint64_t *>())).Times(0);
+ EXPECT_CALL(memory, GetMemoryAtAddress(_, A<uint8_t*>())).Times(0);
+ EXPECT_CALL(memory, GetMemoryAtAddress(_, A<uint16_t*>())).Times(0);
+ EXPECT_CALL(memory, GetMemoryAtAddress(_, A<uint32_t*>())).Times(0);
+ EXPECT_CALL(memory, GetMemoryAtAddress(_, A<uint64_t*>())).Times(0);
}
CFIFrameInfo cfi;
@@ -292,9 +292,9 @@
class MockCFIRuleParserHandler: public CFIRuleParser::Handler {
public:
- MOCK_METHOD1(CFARule, void(const string &));
- MOCK_METHOD1(RARule, void(const string &));
- MOCK_METHOD2(RegisterRule, void(const string &, const string &));
+ MOCK_METHOD1(CFARule, void(const string&));
+ MOCK_METHOD1(RARule, void(const string&));
+ MOCK_METHOD2(RegisterRule, void(const string&, const string&));
};
// A fixture class for testing CFIRuleParser.
@@ -509,12 +509,12 @@
// Saved r0.
EXPECT_CALL(memory,
- GetMemoryAtAddress(stack_top, A<uint64_t *>()))
+ GetMemoryAtAddress(stack_top, A<uint64_t*>()))
.WillRepeatedly(DoAll(SetArgumentPointee<1>(0xdc1975eba8602302ULL),
Return(true)));
// Saved return address.
EXPECT_CALL(memory,
- GetMemoryAtAddress(stack_top + 16, A<uint64_t *>()))
+ GetMemoryAtAddress(stack_top + 16, A<uint64_t*>()))
.WillRepeatedly(DoAll(SetArgumentPointee<1>(0xba5ad6d9acce28deULL),
Return(true)));
diff --git a/src/processor/contained_range_map-inl.h b/src/processor/contained_range_map-inl.h
index 4c0ad41..edd11d7 100644
--- a/src/processor/contained_range_map-inl.h
+++ b/src/processor/contained_range_map-inl.h
@@ -55,7 +55,7 @@
template<typename AddressType, typename EntryType>
bool ContainedRangeMap<AddressType, EntryType>::StoreRange(
- const AddressType &base, const AddressType &size, const EntryType &entry) {
+ const AddressType& base, const AddressType& size, const EntryType& entry) {
AddressType high = base + size - 1;
// Check for undersize or overflow.
@@ -125,7 +125,7 @@
// Optimization: if the iterators are equal, no child ranges would be
// moved. Create the new child range with a NULL map to conserve space
// in leaf nodes, of which there will be many.
- AddressToRangeMap *child_map = NULL;
+ AddressToRangeMap* child_map = NULL;
if (iterator_base != iterator_high) {
// The children of this range that are contained by the new range must
@@ -149,7 +149,7 @@
template<typename AddressType, typename EntryType>
bool ContainedRangeMap<AddressType, EntryType>::RetrieveRange(
- const AddressType &address, EntryType *entry) const {
+ const AddressType& address, EntryType* entry) const {
BPLOG_IF(ERROR, !entry) << "ContainedRangeMap::RetrieveRange requires "
"|entry|";
assert(entry);
diff --git a/src/processor/contained_range_map.h b/src/processor/contained_range_map.h
index 1015ae8..18d03af 100644
--- a/src/processor/contained_range_map.h
+++ b/src/processor/contained_range_map.h
@@ -86,16 +86,16 @@
// grandchildren of this ContainedRangeMap. Returns false for a
// parameter error, or if the ContainedRangeMap hierarchy guarantees
// would be violated.
- bool StoreRange(const AddressType &base,
- const AddressType &size,
- const EntryType &entry);
+ bool StoreRange(const AddressType& base,
+ const AddressType& size,
+ const EntryType& entry);
// Retrieves the most specific (smallest) descendant range encompassing
// the specified address. This method will only return entries held by
// child ranges, and not the entry contained by |this|. This is necessary
// to support a sparsely-populated root range. If no descendant range
// encompasses the address, returns false.
- bool RetrieveRange(const AddressType &address, EntryType *entry) const;
+ bool RetrieveRange(const AddressType& address, EntryType* entry) const;
// Removes all children. Note that Clear only removes descendants,
// leaving the node on which it is called intact. Because the only
@@ -110,7 +110,7 @@
// AddressToRangeMap stores pointers. This makes reparenting simpler in
// StoreRange, because it doesn't need to copy entire objects.
- typedef std::map<AddressType, ContainedRangeMap *> AddressToRangeMap;
+ typedef std::map<AddressType, ContainedRangeMap*> AddressToRangeMap;
typedef typename AddressToRangeMap::const_iterator MapConstIterator;
typedef typename AddressToRangeMap::iterator MapIterator;
typedef typename AddressToRangeMap::value_type MapValue;
@@ -118,8 +118,8 @@
// Creates a new ContainedRangeMap with the specified base address, entry,
// and initial child map, which may be NULL. This is only used internally
// by ContainedRangeMap when it creates a new child.
- ContainedRangeMap(const AddressType &base, const EntryType &entry,
- AddressToRangeMap *map)
+ ContainedRangeMap(const AddressType& base, const EntryType& entry,
+ AddressToRangeMap* map)
: base_(base), entry_(entry), map_(map) {}
// The base address of this range. The high address does not need to
@@ -140,7 +140,7 @@
// The map containing child ranges, keyed by each child range's high
// address. This is a pointer to avoid allocating map structures for
// leaf nodes, where they are not needed.
- AddressToRangeMap *map_;
+ AddressToRangeMap* map_;
};
diff --git a/src/processor/contained_range_map_unittest.cc b/src/processor/contained_range_map_unittest.cc
index e5910da..a97c5d0 100644
--- a/src/processor/contained_range_map_unittest.cc
+++ b/src/processor/contained_range_map_unittest.cc
@@ -256,7 +256,7 @@
} // namespace
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
BPLOG_INIT(&argc, &argv);
return RunTests() ? 0 : 1;
diff --git a/src/processor/disassembler_x86.cc b/src/processor/disassembler_x86.cc
index 55902240..0126767 100644
--- a/src/processor/disassembler_x86.cc
+++ b/src/processor/disassembler_x86.cc
@@ -30,7 +30,7 @@
namespace google_breakpad {
-DisassemblerX86::DisassemblerX86(const uint8_t *bytecode,
+DisassemblerX86::DisassemblerX86(const uint8_t* bytecode,
uint32_t size,
uint32_t virtual_address) :
bytecode_(bytecode),
@@ -62,7 +62,7 @@
return 0;
}
uint32_t instr_size = 0;
- instr_size = libdis::x86_disasm((unsigned char *)bytecode_, size_,
+ instr_size = libdis::x86_disasm((unsigned char*)bytecode_, size_,
virtual_address_, current_byte_offset_,
¤t_instr_);
if (instr_size == 0) {
@@ -78,8 +78,8 @@
if (current_instr_.type == libdis::insn_return)
end_of_block_ = true;
- libdis::x86_op_t *src = libdis::x86_get_src_operand(¤t_instr_);
- libdis::x86_op_t *dest = libdis::x86_get_dest_operand(¤t_instr_);
+ libdis::x86_op_t* src = libdis::x86_get_src_operand(¤t_instr_);
+ libdis::x86_op_t* dest = libdis::x86_get_dest_operand(¤t_instr_);
if (register_valid_) {
switch (current_instr_.group) {
@@ -213,7 +213,7 @@
if (!instr_valid_)
return false;
- libdis::x86_op_t *operand = libdis::x86_get_src_operand(¤t_instr_);
+ libdis::x86_op_t* operand = libdis::x86_get_src_operand(¤t_instr_);
if (!operand || operand->type != libdis::op_expression)
return false;
@@ -227,7 +227,7 @@
if (!instr_valid_)
return false;
- libdis::x86_op_t *operand = libdis::x86_get_dest_operand(¤t_instr_);
+ libdis::x86_op_t* operand = libdis::x86_get_dest_operand(¤t_instr_);
if (!operand || operand->type != libdis::op_expression)
return false;
diff --git a/src/processor/disassembler_x86.h b/src/processor/disassembler_x86.h
index 7106941..ca65b6e 100644
--- a/src/processor/disassembler_x86.h
+++ b/src/processor/disassembler_x86.h
@@ -63,7 +63,7 @@
// TODO(cdn): Modify this class to take a MemoryRegion instead of just
// a raw buffer. This will make it easier to use this on arbitrary
// minidumps without first copying out the code segment.
- DisassemblerX86(const uint8_t *bytecode, uint32_t, uint32_t);
+ DisassemblerX86(const uint8_t* bytecode, uint32_t, uint32_t);
~DisassemblerX86();
// This walks to the next instruction in the memory region and
@@ -102,7 +102,7 @@
bool setBadWrite();
protected:
- const uint8_t *bytecode_;
+ const uint8_t* bytecode_;
uint32_t size_;
uint32_t virtual_address_;
uint32_t current_byte_offset_;
diff --git a/src/processor/exploitability_linux.cc b/src/processor/exploitability_linux.cc
index ccc9f14..798056d 100644
--- a/src/processor/exploitability_linux.cc
+++ b/src/processor/exploitability_linux.cc
@@ -77,13 +77,13 @@
namespace google_breakpad {
-ExploitabilityLinux::ExploitabilityLinux(Minidump *dump,
- ProcessState *process_state)
+ExploitabilityLinux::ExploitabilityLinux(Minidump* dump,
+ ProcessState* process_state)
: Exploitability(dump, process_state),
enable_objdump_(false) { }
-ExploitabilityLinux::ExploitabilityLinux(Minidump *dump,
- ProcessState *process_state,
+ExploitabilityLinux::ExploitabilityLinux(Minidump* dump,
+ ProcessState* process_state,
bool enable_objdump)
: Exploitability(dump, process_state),
enable_objdump_(enable_objdump) { }
@@ -111,12 +111,12 @@
}
// Getting exception data. (It should exist for all minidumps.)
- MinidumpException *exception = dump_->GetException();
+ MinidumpException* exception = dump_->GetException();
if (exception == NULL) {
BPLOG(INFO) << "No exception record.";
return EXPLOITABILITY_ERR_PROCESSING;
}
- const MDRawExceptionStream *raw_exception_stream = exception->exception();
+ const MDRawExceptionStream* raw_exception_stream = exception->exception();
if (raw_exception_stream == NULL) {
BPLOG(INFO) << "No raw exception stream.";
return EXPLOITABILITY_ERR_PROCESSING;
@@ -132,7 +132,7 @@
uint64_t instruction_ptr = 0;
uint64_t stack_ptr = 0;
- const MinidumpContext *context = exception->GetContext();
+ const MinidumpContext* context = exception->GetContext();
if (context == NULL) {
BPLOG(INFO) << "No exception context.";
return EXPLOITABILITY_ERR_PROCESSING;
@@ -174,8 +174,8 @@
BPLOG(INFO) << "MinGW does not support fork and exec. Terminating method.";
#else
// Get memory region containing instruction pointer.
- MinidumpMemoryList *memory_list = dump_->GetMemoryList();
- MinidumpMemoryRegion *memory_region =
+ MinidumpMemoryList* memory_list = dump_->GetMemoryList();
+ MinidumpMemoryRegion* memory_region =
memory_list ?
memory_list->GetMemoryRegionForAddress(instruction_ptr) : NULL;
if (!memory_region) {
@@ -185,15 +185,15 @@
// Get exception data to find architecture.
string architecture = "";
- MinidumpException *exception = dump_->GetException();
+ MinidumpException* exception = dump_->GetException();
// This should never evaluate to true, since this should not be reachable
// without checking for exception data earlier.
if (!exception) {
BPLOG(INFO) << "No exception data.";
return false;
}
- const MDRawExceptionStream *raw_exception_stream = exception->exception();
- const MinidumpContext *context = exception->GetContext();
+ const MDRawExceptionStream* raw_exception_stream = exception->exception();
+ const MinidumpContext* context = exception->GetContext();
// This should not evaluate to true, for the same reason mentioned above.
if (!raw_exception_stream || !context) {
BPLOG(INFO) << "No exception or architecture data.";
@@ -217,7 +217,7 @@
// Get memory region around instruction pointer and the number of bytes
// before and after the instruction pointer in the memory region.
- const uint8_t *raw_memory = memory_region->GetMemory();
+ const uint8_t* raw_memory = memory_region->GetMemory();
const uint64_t base = memory_region->GetBase();
if (base > instruction_ptr) {
BPLOG(ERROR) << "Memory region base value exceeds instruction pointer.";
@@ -275,9 +275,9 @@
}
#ifndef _WIN32
-bool ExploitabilityLinux::CalculateAddress(const string &address_expression,
- const DumpContext &context,
- uint64_t *write_address) {
+bool ExploitabilityLinux::CalculateAddress(const string& address_expression,
+ const DumpContext& context,
+ uint64_t* write_address) {
// The destination should be the format reg+a or reg-a, where reg
// is a register and a is a hexadecimal constant. Although more complex
// expressions can make valid instructions, objdump's disassembly outputs
@@ -395,8 +395,8 @@
// static
bool ExploitabilityLinux::GetObjdumpInstructionLine(
- const char *objdump_output_buffer,
- string *instruction_line) {
+ const char* objdump_output_buffer,
+ string* instruction_line) {
// Put buffer data into stream to output line-by-line.
std::stringstream objdump_stream;
objdump_stream.str(string(objdump_output_buffer));
@@ -420,10 +420,10 @@
return true;
}
-bool ExploitabilityLinux::TokenizeObjdumpInstruction(const string &line,
- string *operation,
- string *dest,
- string *src) {
+bool ExploitabilityLinux::TokenizeObjdumpInstruction(const string& line,
+ string* operation,
+ string* dest,
+ string* src) {
if (!operation || !dest || !src) {
BPLOG(ERROR) << "Null parameters passed.";
return false;
@@ -483,10 +483,10 @@
return true;
}
-bool ExploitabilityLinux::DisassembleBytes(const string &architecture,
- const uint8_t *raw_bytes,
+bool ExploitabilityLinux::DisassembleBytes(const string& architecture,
+ const uint8_t* raw_bytes,
const unsigned int buffer_len,
- char *objdump_output_buffer) {
+ char* objdump_output_buffer) {
if (!raw_bytes || !objdump_output_buffer) {
BPLOG(ERROR) << "Bad input parameters.";
return false;
@@ -514,7 +514,7 @@
"objdump -D -b binary -M intel -m %s %s",
architecture.c_str(),
raw_bytes_tmpfile);
- FILE *objdump_fp = popen(cmd, "r");
+ FILE* objdump_fp = popen(cmd, "r");
if (!objdump_fp) {
fclose(objdump_fp);
unlink(raw_bytes_tmpfile);
@@ -534,12 +534,12 @@
#endif // _WIN32
bool ExploitabilityLinux::StackPointerOffStack(uint64_t stack_ptr) {
- MinidumpLinuxMapsList *linux_maps_list = dump_->GetLinuxMapsList();
+ MinidumpLinuxMapsList* linux_maps_list = dump_->GetLinuxMapsList();
// Inconclusive if there are no mappings available.
if (!linux_maps_list) {
return false;
}
- const MinidumpLinuxMaps *linux_maps =
+ const MinidumpLinuxMaps* linux_maps =
linux_maps_list->GetLinuxMapsForAddress(stack_ptr);
// Checks if the stack pointer maps to a valid mapping and if the mapping
// is not the stack. If the mapping has no name, it is inconclusive whether
@@ -550,10 +550,10 @@
}
bool ExploitabilityLinux::ExecutableStackOrHeap() {
- MinidumpLinuxMapsList *linux_maps_list = dump_->GetLinuxMapsList();
+ MinidumpLinuxMapsList* linux_maps_list = dump_->GetLinuxMapsList();
if (linux_maps_list) {
for (size_t i = 0; i < linux_maps_list->get_maps_count(); i++) {
- const MinidumpLinuxMaps *linux_maps =
+ const MinidumpLinuxMaps* linux_maps =
linux_maps_list->GetLinuxMapsAtIndex(i);
// Check for executable stack or heap for each mapping.
if (linux_maps && (!linux_maps->GetPathname().compare(
@@ -574,15 +574,15 @@
// whether it is in a valid code region. If there is no mapping for the
// instruction pointer, it is indicative that the instruction pointer is
// not within a module, which implies that it is outside a valid area.
- MinidumpLinuxMapsList *linux_maps_list = dump_->GetLinuxMapsList();
- const MinidumpLinuxMaps *linux_maps =
+ MinidumpLinuxMapsList* linux_maps_list = dump_->GetLinuxMapsList();
+ const MinidumpLinuxMaps* linux_maps =
linux_maps_list ?
linux_maps_list->GetLinuxMapsForAddress(instruction_ptr) : NULL;
return linux_maps ? linux_maps->IsExecutable() : false;
}
-bool ExploitabilityLinux::BenignCrashTrigger(const MDRawExceptionStream
- *raw_exception_stream) {
+bool ExploitabilityLinux::BenignCrashTrigger(
+ const MDRawExceptionStream* raw_exception_stream) {
// Check the cause of crash.
// If the exception of the crash is a benign exception,
// it is probably not exploitable.
diff --git a/src/processor/exploitability_linux.h b/src/processor/exploitability_linux.h
index e3ff13b..3664795 100644
--- a/src/processor/exploitability_linux.h
+++ b/src/processor/exploitability_linux.h
@@ -44,8 +44,8 @@
class ExploitabilityLinux : public Exploitability {
public:
- ExploitabilityLinux(Minidump *dump,
- ProcessState *process_state);
+ ExploitabilityLinux(Minidump* dump,
+ ProcessState* process_state);
// Parameters are the minidump to analyze, the object representing process
// state, and whether to enable objdump disassembly.
@@ -53,8 +53,8 @@
// objdump for diassembly. It is used to check the identity of the
// instruction that caused the program to crash. If there are any
// portability concerns, this should not be enabled.
- ExploitabilityLinux(Minidump *dump,
- ProcessState *process_state,
+ ExploitabilityLinux(Minidump* dump,
+ ProcessState* process_state,
bool enable_objdump);
virtual ExploitabilityRating CheckPlatformExploitability();
@@ -68,7 +68,7 @@
// Checks the exception that triggered the creation of the
// minidump and reports whether the exception suggests no exploitability.
- bool BenignCrashTrigger(const MDRawExceptionStream *raw_exception_stream);
+ bool BenignCrashTrigger(const MDRawExceptionStream* raw_exception_stream);
// This method checks if the crash occurred during a write to read-only or
// invalid memory. It does so by checking if the instruction at the
@@ -81,34 +81,34 @@
// buffer, given the desired architecture, the file from which objdump will
// read, and the buffer length. The method returns whether the disassembly
// was a success, and the caller owns all pointers.
- static bool DisassembleBytes(const string &architecture,
- const uint8_t *raw_bytes,
+ static bool DisassembleBytes(const string& architecture,
+ const uint8_t* raw_bytes,
const unsigned int MAX_OBJDUMP_BUFFER_LEN,
- char *objdump_output_buffer);
+ char* objdump_output_buffer);
// Parses the objdump output given in |objdump_output_buffer| and extracts
// the line of the first instruction into |instruction_line|. Returns true
// when the instruction line is successfully extracted.
static bool GetObjdumpInstructionLine(
- const char *objdump_output_buffer,
- string *instruction_line);
+ const char* objdump_output_buffer,
+ string* instruction_line);
// Tokenizes out the operation and operands from a line of instruction
// disassembled by objdump. This method modifies the pointers to match the
// tokens of the instruction, and returns if the tokenizing was a success.
// The caller owns all pointers.
- static bool TokenizeObjdumpInstruction(const string &line,
- string *operation,
- string *dest,
- string *src);
+ static bool TokenizeObjdumpInstruction(const string& line,
+ string* operation,
+ string* dest,
+ string* src);
// Calculates the effective address of an expression in the form reg+a or
// reg-a, where 'reg' is a register and 'a' is a constant, and writes the
// result in the pointer. The method returns whether the calculation was
// a success. The caller owns the pointer.
- static bool CalculateAddress(const string &address_expression,
- const DumpContext &context,
- uint64_t *write_address);
+ static bool CalculateAddress(const string& address_expression,
+ const DumpContext& context,
+ uint64_t* write_address);
#endif // _WIN32
// Checks if the stack pointer points to a memory mapping that is not
diff --git a/src/processor/exploitability_win.cc b/src/processor/exploitability_win.cc
index a1f8703..b74a749 100644
--- a/src/processor/exploitability_win.cc
+++ b/src/processor/exploitability_win.cc
@@ -69,30 +69,30 @@
// The maximum number of bytes to disassemble past the program counter.
static const size_t kDisassembleBytesBeyondPC = 2048;
-ExploitabilityWin::ExploitabilityWin(Minidump *dump,
- ProcessState *process_state)
+ExploitabilityWin::ExploitabilityWin(Minidump* dump,
+ ProcessState* process_state)
: Exploitability(dump, process_state) { }
ExploitabilityRating ExploitabilityWin::CheckPlatformExploitability() {
- MinidumpException *exception = dump_->GetException();
+ MinidumpException* exception = dump_->GetException();
if (!exception) {
BPLOG(INFO) << "Minidump does not have exception record.";
return EXPLOITABILITY_ERR_PROCESSING;
}
- const MDRawExceptionStream *raw_exception = exception->exception();
+ const MDRawExceptionStream* raw_exception = exception->exception();
if (!raw_exception) {
BPLOG(INFO) << "Could not obtain raw exception info.";
return EXPLOITABILITY_ERR_PROCESSING;
}
- const MinidumpContext *context = exception->GetContext();
+ const MinidumpContext* context = exception->GetContext();
if (!context) {
BPLOG(INFO) << "Could not obtain exception context.";
return EXPLOITABILITY_ERR_PROCESSING;
}
- MinidumpMemoryList *memory_list = dump_->GetMemoryList();
+ MinidumpMemoryList* memory_list = dump_->GetMemoryList();
bool memory_available = true;
if (!memory_list) {
BPLOG(INFO) << "Minidump memory segments not available.";
@@ -195,7 +195,7 @@
return EXPLOITABILITY_ERR_PROCESSING;
break;
}
- MinidumpMemoryRegion *instruction_region = 0;
+ MinidumpMemoryRegion* instruction_region = 0;
if (memory_available) {
instruction_region =
memory_list->GetMemoryRegionForAddress(instruction_ptr);
@@ -211,7 +211,7 @@
available_memory = available_memory > kDisassembleBytesBeyondPC ?
kDisassembleBytesBeyondPC : available_memory;
if (available_memory) {
- const uint8_t *raw_memory =
+ const uint8_t* raw_memory =
instruction_region->GetMemory() + memory_offset;
DisassemblerX86 disassembler(raw_memory,
available_memory,
diff --git a/src/processor/fast_source_line_resolver.cc b/src/processor/fast_source_line_resolver.cc
index 4a3d000..3f8ec50 100644
--- a/src/processor/fast_source_line_resolver.cc
+++ b/src/processor/fast_source_line_resolver.cc
@@ -61,7 +61,7 @@
return false;
}
-void FastSourceLineResolver::Module::LookupAddress(StackFrame *frame) const {
+void FastSourceLineResolver::Module::LookupAddress(StackFrame* frame) const {
MemAddr address = frame->instruction - frame->module->base_address();
// First, look for a FUNC record that covers address. Use
@@ -109,7 +109,7 @@
// WFI: WindowsFrameInfo.
// Returns a WFI object reading from a raw memory chunk of data
-WindowsFrameInfo FastSourceLineResolver::CopyWFI(const char *raw) {
+WindowsFrameInfo FastSourceLineResolver::CopyWFI(const char* raw) {
const WindowsFrameInfo::StackInfoTypes type =
static_cast<const WindowsFrameInfo::StackInfoTypes>(
*reinterpret_cast<const int32_t*>(raw));
@@ -117,7 +117,7 @@
// The first 8 bytes of int data are unused.
// They correspond to "StackInfoTypes type_;" and "int valid;"
// data member of WFI.
- const uint32_t *para_uint32 = reinterpret_cast<const uint32_t*>(
+ const uint32_t* para_uint32 = reinterpret_cast<const uint32_t*>(
raw + 2 * sizeof(int32_t));
uint32_t prolog_size = para_uint32[0];;
@@ -126,7 +126,7 @@
uint32_t saved_register_size = para_uint32[3];
uint32_t local_size = para_uint32[4];
uint32_t max_stack_size = para_uint32[5];
- const char *boolean = reinterpret_cast<const char*>(para_uint32 + 6);
+ const char* boolean = reinterpret_cast<const char*>(para_uint32 + 6);
bool allocates_base_pointer = (*boolean != 0);
string program_string = boolean + 1;
@@ -145,15 +145,15 @@
// Does NOT take ownership of mem_buffer.
// In addition, treat mem_buffer as const char*.
bool FastSourceLineResolver::Module::LoadMapFromMemory(
- char *memory_buffer,
+ char* memory_buffer,
size_t memory_buffer_size) {
if (!memory_buffer) return false;
// Read the "is_corrupt" flag.
- const char *mem_buffer = memory_buffer;
+ const char* mem_buffer = memory_buffer;
mem_buffer = SimpleSerializer<bool>::Read(mem_buffer, &is_corrupt_);
- const uint32_t *map_sizes = reinterpret_cast<const uint32_t*>(mem_buffer);
+ const uint32_t* map_sizes = reinterpret_cast<const uint32_t*>(mem_buffer);
unsigned int header_size = kNumberMaps_ * sizeof(unsigned int);
@@ -185,8 +185,8 @@
return true;
}
-WindowsFrameInfo *FastSourceLineResolver::Module::FindWindowsFrameInfo(
- const StackFrame *frame) const {
+WindowsFrameInfo* FastSourceLineResolver::Module::FindWindowsFrameInfo(
+ const StackFrame* frame) const {
MemAddr address = frame->instruction - frame->module->base_address();
scoped_ptr<WindowsFrameInfo> result(new WindowsFrameInfo());
@@ -238,8 +238,8 @@
return NULL;
}
-CFIFrameInfo *FastSourceLineResolver::Module::FindCFIFrameInfo(
- const StackFrame *frame) const {
+CFIFrameInfo* FastSourceLineResolver::Module::FindCFIFrameInfo(
+ const StackFrame* frame) const {
MemAddr address = frame->instruction - frame->module->base_address();
MemAddr initial_base, initial_size;
const char* initial_rules = NULL;
diff --git a/src/processor/fast_source_line_resolver_types.h b/src/processor/fast_source_line_resolver_types.h
index 2c01047..2b2b582 100644
--- a/src/processor/fast_source_line_resolver_types.h
+++ b/src/processor/fast_source_line_resolver_types.h
@@ -54,16 +54,16 @@
namespace google_breakpad {
struct FastSourceLineResolver::Line : public SourceLineResolverBase::Line {
- void CopyFrom(const Line *line_ptr) {
- const char *raw = reinterpret_cast<const char*>(line_ptr);
+ void CopyFrom(const Line* line_ptr) {
+ const char* raw = reinterpret_cast<const char*>(line_ptr);
CopyFrom(raw);
}
// De-serialize the memory data of a Line.
- void CopyFrom(const char *raw) {
+ void CopyFrom(const char* raw) {
address = *(reinterpret_cast<const MemAddr*>(raw));
size = *(reinterpret_cast<const MemAddr*>(raw + sizeof(address)));
- source_file_id = *(reinterpret_cast<const int32_t *>(
+ source_file_id = *(reinterpret_cast<const int32_t*>(
raw + 2 * sizeof(address)));
line = *(reinterpret_cast<const int32_t*>(
raw + 2 * sizeof(address) + sizeof(source_file_id)));
@@ -72,13 +72,13 @@
struct FastSourceLineResolver::Function :
public SourceLineResolverBase::Function {
- void CopyFrom(const Function *func_ptr) {
- const char *raw = reinterpret_cast<const char*>(func_ptr);
+ void CopyFrom(const Function* func_ptr) {
+ const char* raw = reinterpret_cast<const char*>(func_ptr);
CopyFrom(raw);
}
// De-serialize the memory data of a Function.
- void CopyFrom(const char *raw) {
+ void CopyFrom(const char* raw) {
size_t name_size = strlen(raw) + 1;
name = raw;
address = *(reinterpret_cast<const MemAddr*>(raw + name_size));
@@ -95,13 +95,13 @@
struct FastSourceLineResolver::PublicSymbol :
public SourceLineResolverBase::PublicSymbol {
- void CopyFrom(const PublicSymbol *public_symbol_ptr) {
- const char *raw = reinterpret_cast<const char*>(public_symbol_ptr);
+ void CopyFrom(const PublicSymbol* public_symbol_ptr) {
+ const char* raw = reinterpret_cast<const char*>(public_symbol_ptr);
CopyFrom(raw);
}
// De-serialize the memory data of a PublicSymbol.
- void CopyFrom(const char *raw) {
+ void CopyFrom(const char* raw) {
size_t name_size = strlen(raw) + 1;
name = raw;
address = *(reinterpret_cast<const MemAddr*>(raw + name_size));
@@ -112,15 +112,15 @@
class FastSourceLineResolver::Module: public SourceLineResolverBase::Module {
public:
- explicit Module(const string &name) : name_(name), is_corrupt_(false) { }
+ explicit Module(const string& name) : name_(name), is_corrupt_(false) { }
virtual ~Module() { }
// Looks up the given relative address, and fills the StackFrame struct
// with the result.
- virtual void LookupAddress(StackFrame *frame) const;
+ virtual void LookupAddress(StackFrame* frame) const;
// Loads a map from the given buffer in char* type.
- virtual bool LoadMapFromMemory(char *memory_buffer,
+ virtual bool LoadMapFromMemory(char* memory_buffer,
size_t memory_buffer_size);
// Tells whether the loaded symbol data is corrupt. Return value is
@@ -132,13 +132,13 @@
// is not available, returns NULL. A NULL return value does not indicate
// an error. The caller takes ownership of any returned WindowsFrameInfo
// object.
- virtual WindowsFrameInfo *FindWindowsFrameInfo(const StackFrame *frame) const;
+ virtual WindowsFrameInfo* FindWindowsFrameInfo(const StackFrame* frame) const;
// If CFI stack walking information is available covering ADDRESS,
// return a CFIFrameInfo structure describing it. If the information
// is not available, return NULL. The caller takes ownership of any
// returned CFIFrameInfo object.
- virtual CFIFrameInfo *FindCFIFrameInfo(const StackFrame *frame) const;
+ virtual CFIFrameInfo* FindCFIFrameInfo(const StackFrame* frame) const;
// Number of serialized map components of Module.
static const int kNumberMaps_ = 5 + WindowsFrameInfo::STACK_INFO_LAST;
diff --git a/src/processor/fast_source_line_resolver_unittest.cc b/src/processor/fast_source_line_resolver_unittest.cc
index 87b13c5..0ec5f91 100644
--- a/src/processor/fast_source_line_resolver_unittest.cc
+++ b/src/processor/fast_source_line_resolver_unittest.cc
@@ -94,15 +94,15 @@
class MockMemoryRegion: public MemoryRegion {
uint64_t GetBase() const { return 0x10000; }
uint32_t GetSize() const { return 0x01000; }
- bool GetMemoryAtAddress(uint64_t address, uint8_t *value) const {
+ bool GetMemoryAtAddress(uint64_t address, uint8_t* value) const {
*value = address & 0xff;
return true;
}
- bool GetMemoryAtAddress(uint64_t address, uint16_t *value) const {
+ bool GetMemoryAtAddress(uint64_t address, uint16_t* value) const {
*value = address & 0xffff;
return true;
}
- bool GetMemoryAtAddress(uint64_t address, uint32_t *value) const {
+ bool GetMemoryAtAddress(uint64_t address, uint32_t* value) const {
switch (address) {
case 0x10008: *value = 0x98ecadc3; break; // saved %ebx
case 0x1000c: *value = 0x878f7524; break; // saved %esi
@@ -113,7 +113,7 @@
}
return true;
}
- bool GetMemoryAtAddress(uint64_t address, uint64_t *value) const {
+ bool GetMemoryAtAddress(uint64_t address, uint64_t* value) const {
*value = address;
return true;
}
@@ -127,9 +127,9 @@
// EXPECTED's.) Also verify that ACTUAL has associations for ".ra" and
// ".cfa".
static bool VerifyRegisters(
- const char *file, int line,
- const CFIFrameInfo::RegisterValueMap<uint32_t> &expected,
- const CFIFrameInfo::RegisterValueMap<uint32_t> &actual) {
+ const char* file, int line,
+ const CFIFrameInfo::RegisterValueMap<uint32_t>& expected,
+ const CFIFrameInfo::RegisterValueMap<uint32_t>& actual) {
CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator a;
a = actual.find(".cfa");
if (a == actual.end())
@@ -158,7 +158,7 @@
return true;
}
-static bool VerifyEmpty(const StackFrame &frame) {
+static bool VerifyEmpty(const StackFrame& frame) {
if (frame.function_name.empty() &&
frame.source_file_name.empty() &&
frame.source_line == 0)
@@ -166,7 +166,7 @@
return false;
}
-static void ClearSourceLineInfo(StackFrame *frame) {
+static void ClearSourceLineInfo(StackFrame* frame) {
frame->function_name.clear();
frame->module = NULL;
frame->source_file_name.clear();
@@ -467,7 +467,7 @@
}
TEST_F(TestFastSourceLineResolver, CompareModule) {
- char *symbol_data;
+ char* symbol_data;
size_t symbol_data_size;
string symbol_data_string;
string filename;
@@ -486,7 +486,7 @@
} // namespace
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
diff --git a/src/processor/logging.cc b/src/processor/logging.cc
index d59175a..3c5b161 100644
--- a/src/processor/logging.cc
+++ b/src/processor/logging.cc
@@ -47,8 +47,8 @@
namespace google_breakpad {
-LogStream::LogStream(std::ostream &stream, Severity severity,
- const char *file, int line)
+LogStream::LogStream(std::ostream& stream, Severity severity,
+ const char* file, int line)
: stream_(stream) {
time_t clock;
time(&clock);
@@ -61,7 +61,7 @@
char time_string[20];
strftime(time_string, sizeof(time_string), "%Y-%m-%d %H:%M:%S", &tm_struct);
- const char *severity_string = "UNKNOWN_SEVERITY";
+ const char* severity_string = "UNKNOWN_SEVERITY";
switch (severity) {
case SEVERITY_INFO:
severity_string = "INFO";
@@ -100,7 +100,7 @@
return string(buffer);
}
-int ErrnoString(string *error_string) {
+int ErrnoString(string* error_string) {
assert(error_string);
// strerror isn't necessarily thread-safe. strerror_r would be preferrable,
diff --git a/src/processor/logging.h b/src/processor/logging.h
index 43f3cfc..e6c6eee 100644
--- a/src/processor/logging.h
+++ b/src/processor/logging.h
@@ -89,22 +89,22 @@
// Begin logging a message to the stream identified by |stream|, at the
// indicated severity. The file and line parameters should be set so as to
// identify the line of source code that is producing a message.
- LogStream(std::ostream &stream, Severity severity,
- const char *file, int line);
+ LogStream(std::ostream& stream, Severity severity,
+ const char* file, int line);
// Finish logging by printing a newline and flushing the output stream.
~LogStream();
- template<typename T> std::ostream& operator<<(const T &t) {
+ template<typename T> std::ostream& operator<<(const T& t) {
return stream_ << t;
}
private:
- std::ostream &stream_;
+ std::ostream& stream_;
// Disallow copy constructor and assignment operator
- explicit LogStream(const LogStream &that);
- void operator=(const LogStream &that);
+ explicit LogStream(const LogStream& that);
+ void operator=(const LogStream& that);
};
// This class is used to explicitly ignore values in the conditional logging
@@ -116,7 +116,7 @@
// This has to be an operator with a precedence lower than << but higher
// than ?:
- void operator&(std::ostream &) {}
+ void operator&(std::ostream&) {}
};
// Returns number formatted as a hexadecimal string, such as "0x7b".
@@ -127,7 +127,7 @@
// Returns the error code as set in the global errno variable, and sets
// error_string, a required argument, to a string describing that error
// code.
-int ErrnoString(string *error_string);
+int ErrnoString(string* error_string);
} // namespace google_breakpad
diff --git a/src/processor/map_serializers-inl.h b/src/processor/map_serializers-inl.h
index 61c7bbd..4933f90 100644
--- a/src/processor/map_serializers-inl.h
+++ b/src/processor/map_serializers-inl.h
@@ -53,7 +53,7 @@
template<typename Key, typename Value>
size_t StdMapSerializer<Key, Value>::SizeOf(
- const std::map<Key, Value> &m) const {
+ const std::map<Key, Value>& m) const {
size_t size = 0;
size_t header_size = (1 + m.size()) * sizeof(uint32_t);
size += header_size;
@@ -67,22 +67,22 @@
}
template<typename Key, typename Value>
-char *StdMapSerializer<Key, Value>::Write(const std::map<Key, Value> &m,
- char *dest) const {
+char* StdMapSerializer<Key, Value>::Write(const std::map<Key, Value>& m,
+ char* dest) const {
if (!dest) {
BPLOG(ERROR) << "StdMapSerializer failed: write to NULL address.";
return NULL;
}
- char *start_address = dest;
+ char* start_address = dest;
// Write header:
// Number of nodes.
dest = SimpleSerializer<uint32_t>::Write(m.size(), dest);
// Nodes offsets.
- uint32_t *offsets = reinterpret_cast<uint32_t*>(dest);
+ uint32_t* offsets = reinterpret_cast<uint32_t*>(dest);
dest += sizeof(uint32_t) * m.size();
- char *key_address = dest;
+ char* key_address = dest;
dest += sizeof(Key) * m.size();
// Traverse map.
@@ -97,12 +97,12 @@
}
template<typename Key, typename Value>
-char *StdMapSerializer<Key, Value>::Serialize(
- const std::map<Key, Value> &m, unsigned int *size) const {
+char* StdMapSerializer<Key, Value>::Serialize(
+ const std::map<Key, Value>& m, unsigned int* size) const {
// Compute size of memory to be allocated.
unsigned int size_to_alloc = SizeOf(m);
// Allocate memory.
- char *serialized_data = new char[size_to_alloc];
+ char* serialized_data = new char[size_to_alloc];
if (!serialized_data) {
BPLOG(INFO) << "StdMapSerializer memory allocation failed.";
if (size) *size = 0;
@@ -117,7 +117,7 @@
template<typename Address, typename Entry>
size_t RangeMapSerializer<Address, Entry>::SizeOf(
- const RangeMap<Address, Entry> &m) const {
+ const RangeMap<Address, Entry>& m) const {
size_t size = 0;
size_t header_size = (1 + m.map_.size()) * sizeof(uint32_t);
size += header_size;
@@ -135,22 +135,22 @@
}
template<typename Address, typename Entry>
-char *RangeMapSerializer<Address, Entry>::Write(
- const RangeMap<Address, Entry> &m, char *dest) const {
+char* RangeMapSerializer<Address, Entry>::Write(
+ const RangeMap<Address, Entry>& m, char* dest) const {
if (!dest) {
BPLOG(ERROR) << "RangeMapSerializer failed: write to NULL address.";
return NULL;
}
- char *start_address = dest;
+ char* start_address = dest;
// Write header:
// Number of nodes.
dest = SimpleSerializer<uint32_t>::Write(m.map_.size(), dest);
// Nodes offsets.
- uint32_t *offsets = reinterpret_cast<uint32_t*>(dest);
+ uint32_t* offsets = reinterpret_cast<uint32_t*>(dest);
dest += sizeof(uint32_t) * m.map_.size();
- char *key_address = dest;
+ char* key_address = dest;
dest += sizeof(Address) * m.map_.size();
// Traverse map.
@@ -166,12 +166,12 @@
}
template<typename Address, typename Entry>
-char *RangeMapSerializer<Address, Entry>::Serialize(
- const RangeMap<Address, Entry> &m, unsigned int *size) const {
+char* RangeMapSerializer<Address, Entry>::Serialize(
+ const RangeMap<Address, Entry>& m, unsigned int* size) const {
// Compute size of memory to be allocated.
unsigned int size_to_alloc = SizeOf(m);
// Allocate memory.
- char *serialized_data = new char[size_to_alloc];
+ char* serialized_data = new char[size_to_alloc];
if (!serialized_data) {
BPLOG(INFO) << "RangeMapSerializer memory allocation failed.";
if (size) *size = 0;
@@ -188,7 +188,7 @@
template<class AddrType, class EntryType>
size_t ContainedRangeMapSerializer<AddrType, EntryType>::SizeOf(
- const ContainedRangeMap<AddrType, EntryType> *m) const {
+ const ContainedRangeMap<AddrType, EntryType>* m) const {
size_t size = 0;
size_t header_size = addr_serializer_.SizeOf(m->base_)
+ entry_serializer_.SizeOf(m->entry_)
@@ -209,8 +209,8 @@
}
template<class AddrType, class EntryType>
-char *ContainedRangeMapSerializer<AddrType, EntryType>::Write(
- const ContainedRangeMap<AddrType, EntryType> *m, char *dest) const {
+char* ContainedRangeMapSerializer<AddrType, EntryType>::Write(
+ const ContainedRangeMap<AddrType, EntryType>* m, char* dest) const {
if (!dest) {
BPLOG(ERROR) << "StdMapSerializer failed: write to NULL address.";
return NULL;
@@ -221,15 +221,15 @@
dest = entry_serializer_.Write(m->entry_, dest);
// Write map<<AddrType, ContainedRangeMap*>:
- char *map_address = dest;
+ char* map_address = dest;
if (m->map_ == NULL) {
dest = SimpleSerializer<uint32_t>::Write(0, dest);
} else {
dest = SimpleSerializer<uint32_t>::Write(m->map_->size(), dest);
- uint32_t *offsets = reinterpret_cast<uint32_t*>(dest);
+ uint32_t* offsets = reinterpret_cast<uint32_t*>(dest);
dest += sizeof(uint32_t) * m->map_->size();
- char *key_address = dest;
+ char* key_address = dest;
dest += sizeof(AddrType) * m->map_->size();
// Traverse map.
@@ -246,11 +246,11 @@
}
template<class AddrType, class EntryType>
-char *ContainedRangeMapSerializer<AddrType, EntryType>::Serialize(
- const ContainedRangeMap<AddrType, EntryType> *m, unsigned int *size) const {
+char* ContainedRangeMapSerializer<AddrType, EntryType>::Serialize(
+ const ContainedRangeMap<AddrType, EntryType>* m, unsigned int* size) const {
unsigned int size_to_alloc = SizeOf(m);
// Allocating memory.
- char *serialized_data = new char[size_to_alloc];
+ char* serialized_data = new char[size_to_alloc];
if (!serialized_data) {
BPLOG(INFO) << "ContainedRangeMapSerializer memory allocation failed.";
if (size) *size = 0;
diff --git a/src/processor/map_serializers.h b/src/processor/map_serializers.h
index a0b9d3f..3d50415 100644
--- a/src/processor/map_serializers.h
+++ b/src/processor/map_serializers.h
@@ -53,20 +53,20 @@
class StdMapSerializer {
public:
// Calculate the memory size of serialized data.
- size_t SizeOf(const std::map<Key, Value> &m) const;
+ size_t SizeOf(const std::map<Key, Value>& m) const;
// Writes the serialized data to memory with start address = dest,
// and returns the "end" of data, i.e., return the address follow the final
// byte of data.
// NOTE: caller has to allocate enough memory before invoke Write() method.
- char* Write(const std::map<Key, Value> &m, char* dest) const;
+ char* Write(const std::map<Key, Value>& m, char* dest) const;
// Serializes a std::map object into a chunk of memory data with format
// described in "StaticMap.h" comment.
// Returns a pointer to the serialized data. If size != NULL, *size is set
// to the size of serialized data, i.e., SizeOf(m).
// Caller has the ownership of memory allocated as "new char[]".
- char* Serialize(const std::map<Key, Value> &m, unsigned int *size) const;
+ char* Serialize(const std::map<Key, Value>& m, unsigned int* size) const;
private:
SimpleSerializer<Key> key_serializer_;
@@ -79,14 +79,14 @@
class AddressMapSerializer {
public:
// Calculate the memory size of serialized data.
- size_t SizeOf(const AddressMap<Addr, Entry> &m) const {
+ size_t SizeOf(const AddressMap<Addr, Entry>& m) const {
return std_map_serializer_.SizeOf(m.map_);
}
// Write the serialized data to specified memory location. Return the "end"
// of data, i.e., return the address after the final byte of data.
// NOTE: caller has to allocate enough memory before invoke Write() method.
- char* Write(const AddressMap<Addr, Entry> &m, char *dest) const {
+ char* Write(const AddressMap<Addr, Entry>& m, char* dest) const {
return std_map_serializer_.Write(m.map_, dest);
}
@@ -94,7 +94,7 @@
// Returns a pointer to the serialized data. If size != NULL, *size is set
// to the size of serialized data, i.e., SizeOf(m).
// Caller has the ownership of memory allocated as "new char[]".
- char* Serialize(const AddressMap<Addr, Entry> &m, unsigned int *size) const {
+ char* Serialize(const AddressMap<Addr, Entry>& m, unsigned int* size) const {
return std_map_serializer_.Serialize(m.map_, size);
}
@@ -110,18 +110,18 @@
class RangeMapSerializer {
public:
// Calculate the memory size of serialized data.
- size_t SizeOf(const RangeMap<Address, Entry> &m) const;
+ size_t SizeOf(const RangeMap<Address, Entry>& m) const;
// Write the serialized data to specified memory location. Return the "end"
// of data, i.e., return the address after the final byte of data.
// NOTE: caller has to allocate enough memory before invoke Write() method.
- char* Write(const RangeMap<Address, Entry> &m, char* dest) const;
+ char* Write(const RangeMap<Address, Entry>& m, char* dest) const;
// Serializes a RangeMap object into a chunk of memory data.
// Returns a pointer to the serialized data. If size != NULL, *size is set
// to the size of serialized data, i.e., SizeOf(m).
// Caller has the ownership of memory allocated as "new char[]".
- char* Serialize(const RangeMap<Address, Entry> &m, unsigned int *size) const;
+ char* Serialize(const RangeMap<Address, Entry>& m, unsigned int* size) const;
private:
// Convenient type name for Range.
@@ -139,20 +139,20 @@
class ContainedRangeMapSerializer {
public:
// Calculate the memory size of serialized data.
- size_t SizeOf(const ContainedRangeMap<AddrType, EntryType> *m) const;
+ size_t SizeOf(const ContainedRangeMap<AddrType, EntryType>* m) const;
// Write the serialized data to specified memory location. Return the "end"
// of data, i.e., return the address after the final byte of data.
// NOTE: caller has to allocate enough memory before invoke Write() method.
- char* Write(const ContainedRangeMap<AddrType, EntryType> *m,
+ char* Write(const ContainedRangeMap<AddrType, EntryType>* m,
char* dest) const;
// Serializes a ContainedRangeMap object into a chunk of memory data.
// Returns a pointer to the serialized data. If size != NULL, *size is set
// to the size of serialized data, i.e., SizeOf(m).
// Caller has the ownership of memory allocated as "new char[]".
- char* Serialize(const ContainedRangeMap<AddrType, EntryType> *m,
- unsigned int *size) const;
+ char* Serialize(const ContainedRangeMap<AddrType, EntryType>* m,
+ unsigned int* size) const;
private:
// Convenient type name for the underlying map type.
diff --git a/src/processor/map_serializers_unittest.cc b/src/processor/map_serializers_unittest.cc
index 0d872ec..48b9c4b 100644
--- a/src/processor/map_serializers_unittest.cc
+++ b/src/processor/map_serializers_unittest.cc
@@ -63,7 +63,7 @@
std::map<AddrType, EntryType> std_map_;
google_breakpad::StdMapSerializer<AddrType, EntryType> serializer_;
uint32_t serialized_size_;
- char *serialized_data_;
+ char* serialized_data_;
};
TEST_F(TestStdMapSerializer, EmptyMapTestCase) {
@@ -135,7 +135,7 @@
google_breakpad::AddressMap<AddrType, EntryType> address_map_;
google_breakpad::AddressMapSerializer<AddrType, EntryType> serializer_;
uint32_t serialized_size_;
- char *serialized_data_;
+ char* serialized_data_;
};
TEST_F(TestAddressMapSerializer, EmptyMapTestCase) {
@@ -210,7 +210,7 @@
google_breakpad::RangeMap<AddrType, EntryType> range_map_;
google_breakpad::RangeMapSerializer<AddrType, EntryType> serializer_;
uint32_t serialized_size_;
- char *serialized_data_;
+ char* serialized_data_;
};
TEST_F(TestRangeMapSerializer, EmptyMapTestCase) {
@@ -283,7 +283,7 @@
google_breakpad::ContainedRangeMap<AddrType, EntryType> crm_map_;
google_breakpad::ContainedRangeMapSerializer<AddrType, EntryType> serializer_;
uint32_t serialized_size_;
- char *serialized_data_;
+ char* serialized_data_;
};
TEST_F(TestContainedRangeMapSerializer, EmptyMapTestCase) {
@@ -379,7 +379,7 @@
}
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
diff --git a/src/processor/microdump_stackwalk.cc b/src/processor/microdump_stackwalk.cc
index 220396e..03fa77e 100644
--- a/src/processor/microdump_stackwalk.cc
+++ b/src/processor/microdump_stackwalk.cc
@@ -140,7 +140,7 @@
options->machine_readable = false;
options->output_stack_contents = false;
- while ((ch = getopt(argc, (char * const *)argv, "hms")) != -1) {
+ while ((ch = getopt(argc, (char * const*)argv, "hms")) != -1) {
switch (ch) {
case 'h':
Usage(argc, argv, false);
diff --git a/src/processor/minidump.cc b/src/processor/minidump.cc
index f0075eb..1f47955 100644
--- a/src/processor/minidump.cc
+++ b/src/processor/minidump.cc
@@ -1611,7 +1611,7 @@
}
-bool MinidumpThread::GetThreadID(uint32_t *thread_id) const {
+bool MinidumpThread::GetThreadID(uint32_t* thread_id) const {
BPLOG_IF(ERROR, !thread_id) << "MinidumpThread::GetThreadID requires "
"|thread_id|";
assert(thread_id);
@@ -1973,14 +1973,14 @@
if (!has_debug_info_)
return "";
- MinidumpSystemInfo *minidump_system_info = minidump_->GetSystemInfo();
+ MinidumpSystemInfo* minidump_system_info = minidump_->GetSystemInfo();
if (!minidump_system_info) {
BPLOG(ERROR) << "MinidumpModule code_identifier requires "
"MinidumpSystemInfo";
return "";
}
- const MDRawSystemInfo *raw_system_info = minidump_system_info->system_info();
+ const MDRawSystemInfo* raw_system_info = minidump_system_info->system_info();
if (!raw_system_info) {
BPLOG(ERROR) << "MinidumpModule code_identifier requires MDRawSystemInfo";
return "";
@@ -2093,7 +2093,7 @@
// No usable CodeView record. Try the miscellaneous debug record.
if (misc_record_) {
const MDImageDebugMisc* misc_record =
- reinterpret_cast<const MDImageDebugMisc *>(&(*misc_record_)[0]);
+ reinterpret_cast<const MDImageDebugMisc*>(&(*misc_record_)[0]);
if (!misc_record->unicode) {
// If it's not Unicode, just stuff it into the string. It's unclear
// if misc_record->data is 0-terminated, so use an explicit size.
@@ -2549,7 +2549,7 @@
code_identifier().c_str());
uint32_t cv_record_size;
- const uint8_t *cv_record = GetCVRecord(&cv_record_size);
+ const uint8_t* cv_record = GetCVRecord(&cv_record_size);
if (cv_record) {
if (cv_record_signature_ == MD_CVINFOPDB70_SIGNATURE) {
const MDCVInfoPDB70* cv_record_70 =
@@ -3215,7 +3215,7 @@
}
-bool MinidumpException::GetThreadID(uint32_t *thread_id) const {
+bool MinidumpException::GetThreadID(uint32_t* thread_id) const {
BPLOG_IF(ERROR, !thread_id) << "MinidumpException::GetThreadID requires "
"|thread_id|";
assert(thread_id);
@@ -3699,14 +3699,14 @@
return "";
}
- MinidumpSystemInfo *minidump_system_info = minidump_->GetSystemInfo();
+ MinidumpSystemInfo* minidump_system_info = minidump_->GetSystemInfo();
if (!minidump_system_info) {
BPLOG(ERROR) << "MinidumpUnloadedModule code_identifier requires "
"MinidumpSystemInfo";
return "";
}
- const MDRawSystemInfo *raw_system_info = minidump_system_info->system_info();
+ const MDRawSystemInfo* raw_system_info = minidump_system_info->system_info();
if (!raw_system_info) {
BPLOG(ERROR) << "MinidumpUnloadedModule code_identifier requires "
<< "MDRawSystemInfo";
@@ -4356,7 +4356,7 @@
}
-bool MinidumpBreakpadInfo::GetDumpThreadID(uint32_t *thread_id) const {
+bool MinidumpBreakpadInfo::GetDumpThreadID(uint32_t* thread_id) const {
BPLOG_IF(ERROR, !thread_id) << "MinidumpBreakpadInfo::GetDumpThreadID "
"requires |thread_id|";
assert(thread_id);
@@ -4377,7 +4377,7 @@
}
-bool MinidumpBreakpadInfo::GetRequestingThreadID(uint32_t *thread_id)
+bool MinidumpBreakpadInfo::GetRequestingThreadID(uint32_t* thread_id)
const {
BPLOG_IF(ERROR, !thread_id) << "MinidumpBreakpadInfo::GetRequestingThreadID "
"requires |thread_id|";
@@ -4695,7 +4695,7 @@
// MinidumpLinuxMaps
//
-MinidumpLinuxMaps::MinidumpLinuxMaps(Minidump *minidump)
+MinidumpLinuxMaps::MinidumpLinuxMaps(Minidump* minidump)
: MinidumpObject(minidump) {
}
@@ -4711,7 +4711,7 @@
// MinidumpLinuxMapsList
//
-MinidumpLinuxMapsList::MinidumpLinuxMapsList(Minidump *minidump)
+MinidumpLinuxMapsList::MinidumpLinuxMapsList(Minidump* minidump)
: MinidumpStream(minidump),
maps_(NULL),
maps_count_(0) {
@@ -4726,7 +4726,7 @@
}
}
-const MinidumpLinuxMaps *MinidumpLinuxMapsList::GetLinuxMapsForAddress(
+const MinidumpLinuxMaps* MinidumpLinuxMapsList::GetLinuxMapsForAddress(
uint64_t address) const {
if (!valid_ || (maps_ == NULL)) {
BPLOG(ERROR) << "Invalid MinidumpLinuxMapsList for GetLinuxMapsForAddress";
@@ -4748,7 +4748,7 @@
return NULL;
}
-const MinidumpLinuxMaps *MinidumpLinuxMapsList::GetLinuxMapsAtIndex(
+const MinidumpLinuxMaps* MinidumpLinuxMapsList::GetLinuxMapsAtIndex(
unsigned int index) const {
if (!valid_ || (maps_ == NULL)) {
BPLOG(ERROR) << "Invalid MinidumpLinuxMapsList for GetLinuxMapsAtIndex";
@@ -5090,7 +5090,7 @@
return true;
}
-bool Minidump::GetContextCPUFlagsFromSystemInfo(uint32_t *context_cpu_flags) {
+bool Minidump::GetContextCPUFlagsFromSystemInfo(uint32_t* context_cpu_flags) {
// Initialize output parameters
*context_cpu_flags = 0;
@@ -5366,8 +5366,8 @@
return GetStream(&memory_info_list);
}
-MinidumpLinuxMapsList *Minidump::GetLinuxMapsList() {
- MinidumpLinuxMapsList *linux_maps_list;
+MinidumpLinuxMapsList* Minidump::GetLinuxMapsList() {
+ MinidumpLinuxMapsList* linux_maps_list;
return GetStream(&linux_maps_list);
}
diff --git a/src/processor/minidump_dump.cc b/src/processor/minidump_dump.cc
index 4716aa0..06802f2 100644
--- a/src/processor/minidump_dump.cc
+++ b/src/processor/minidump_dump.cc
@@ -91,7 +91,7 @@
// in compatibility warnings.
uint32_t int_remaining = remaining;
printf("%.*s", int_remaining, &contents[current_offset]);
- char *next_null = reinterpret_cast<char *>(
+ char *next_null = reinterpret_cast<char*>(
memchr(&contents[current_offset], 0, remaining));
if (next_null == NULL)
break;
@@ -241,7 +241,7 @@
SetupOptions(int argc, char *argv[], Options *options) {
int ch;
- while ((ch = getopt(argc, (char * const *)argv, "xh")) != -1) {
+ while ((ch = getopt(argc, (char * const*)argv, "xh")) != -1) {
switch (ch) {
case 'x':
options->hexdump = true;
diff --git a/src/processor/minidump_processor.cc b/src/processor/minidump_processor.cc
index a90e618..04b7e12 100644
--- a/src/processor/minidump_processor.cc
+++ b/src/processor/minidump_processor.cc
@@ -48,16 +48,16 @@
namespace google_breakpad {
-MinidumpProcessor::MinidumpProcessor(SymbolSupplier *supplier,
- SourceLineResolverInterface *resolver)
+MinidumpProcessor::MinidumpProcessor(SymbolSupplier* supplier,
+ SourceLineResolverInterface* resolver)
: frame_symbolizer_(new StackFrameSymbolizer(supplier, resolver)),
own_frame_symbolizer_(true),
enable_exploitability_(false),
enable_objdump_(false) {
}
-MinidumpProcessor::MinidumpProcessor(SymbolSupplier *supplier,
- SourceLineResolverInterface *resolver,
+MinidumpProcessor::MinidumpProcessor(SymbolSupplier* supplier,
+ SourceLineResolverInterface* resolver,
bool enable_exploitability)
: frame_symbolizer_(new StackFrameSymbolizer(supplier, resolver)),
own_frame_symbolizer_(true),
@@ -65,7 +65,7 @@
enable_objdump_(false) {
}
-MinidumpProcessor::MinidumpProcessor(StackFrameSymbolizer *frame_symbolizer,
+MinidumpProcessor::MinidumpProcessor(StackFrameSymbolizer* frame_symbolizer,
bool enable_exploitability)
: frame_symbolizer_(frame_symbolizer),
own_frame_symbolizer_(false),
@@ -79,13 +79,13 @@
}
ProcessResult MinidumpProcessor::Process(
- Minidump *dump, ProcessState *process_state) {
+ Minidump* dump, ProcessState* process_state) {
assert(dump);
assert(process_state);
process_state->Clear();
- const MDRawHeader *header = dump->header();
+ const MDRawHeader* header = dump->header();
if (!header) {
BPLOG(ERROR) << "Minidump " << dump->path() << " has no header";
return PROCESS_ERROR_NO_MINIDUMP_HEADER;
@@ -103,14 +103,14 @@
uint32_t requesting_thread_id = 0;
bool has_requesting_thread = false;
- MinidumpBreakpadInfo *breakpad_info = dump->GetBreakpadInfo();
+ MinidumpBreakpadInfo* breakpad_info = dump->GetBreakpadInfo();
if (breakpad_info) {
has_dump_thread = breakpad_info->GetDumpThreadID(&dump_thread_id);
has_requesting_thread =
breakpad_info->GetRequestingThreadID(&requesting_thread_id);
}
- MinidumpException *exception = dump->GetException();
+ MinidumpException* exception = dump->GetException();
if (exception) {
process_state->crashed_ = true;
has_requesting_thread = exception->GetThreadID(&requesting_thread_id);
@@ -143,7 +143,7 @@
// This will just return an empty string if it doesn't exist.
process_state->assertion_ = GetAssertion(dump);
- MinidumpModuleList *module_list = dump->GetModuleList();
+ MinidumpModuleList* module_list = dump->GetModuleList();
// Put a copy of the module list into ProcessState object. This is not
// necessarily a MinidumpModuleList, but it adheres to the CodeModules
@@ -163,19 +163,19 @@
}
}
- MinidumpUnloadedModuleList *unloaded_module_list =
+ MinidumpUnloadedModuleList* unloaded_module_list =
dump->GetUnloadedModuleList();
if (unloaded_module_list) {
process_state->unloaded_modules_ = unloaded_module_list->Copy();
}
- MinidumpMemoryList *memory_list = dump->GetMemoryList();
+ MinidumpMemoryList* memory_list = dump->GetMemoryList();
if (memory_list) {
BPLOG(INFO) << "Found " << memory_list->region_count()
<< " memory regions.";
}
- MinidumpThreadList *threads = dump->GetThreadList();
+ MinidumpThreadList* threads = dump->GetThreadList();
if (!threads) {
BPLOG(ERROR) << "Minidump " << dump->path() << " has no thread list";
return PROCESS_ERROR_NO_THREAD_LIST;
@@ -207,7 +207,7 @@
thread_index, thread_count);
string thread_string = dump->path() + ":" + thread_string_buffer;
- MinidumpThread *thread = threads->GetThreadAtIndex(thread_index);
+ MinidumpThread* thread = threads->GetThreadAtIndex(thread_index);
if (!thread) {
BPLOG(ERROR) << "Could not get thread for " << thread_string;
return PROCESS_ERROR_GETTING_THREAD;
@@ -230,7 +230,7 @@
continue;
}
- MinidumpContext *context = thread->GetContext();
+ MinidumpContext* context = thread->GetContext();
if (has_requesting_thread && thread_id == requesting_thread_id) {
if (found_requesting_thread) {
@@ -257,7 +257,7 @@
// would not result in the expected stack trace from the time of the
// crash. If the exception context is invalid, however, we fall back
// on the thread context.
- MinidumpContext *ctx = exception->GetContext();
+ MinidumpContext* ctx = exception->GetContext();
context = ctx ? ctx : thread->GetContext();
}
}
@@ -265,7 +265,7 @@
// If the memory region for the stack cannot be read using the RVA stored
// in the memory descriptor inside MINIDUMP_THREAD, try to locate and use
// a memory region (containing the stack) from the minidump memory list.
- MinidumpMemoryRegion *thread_memory = thread->GetMemory();
+ MinidumpMemoryRegion* thread_memory = thread->GetMemory();
if (!thread_memory && memory_list) {
uint64_t start_stack_memory_range = thread->GetStartOfStackMemoryRange();
if (start_stack_memory_range) {
@@ -350,7 +350,7 @@
}
ProcessResult MinidumpProcessor::Process(
- const string &minidump_file, ProcessState *process_state) {
+ const string& minidump_file, ProcessState* process_state) {
BPLOG(INFO) << "Processing minidump in file " << minidump_file;
Minidump dump(minidump_file);
@@ -365,9 +365,9 @@
// Returns the MDRawSystemInfo from a minidump, or NULL if system info is
// not available from the minidump. If system_info is non-NULL, it is used
// to pass back the MinidumpSystemInfo object.
-static const MDRawSystemInfo* GetSystemInfo(Minidump *dump,
- MinidumpSystemInfo **system_info) {
- MinidumpSystemInfo *minidump_system_info = dump->GetSystemInfo();
+static const MDRawSystemInfo* GetSystemInfo(Minidump* dump,
+ MinidumpSystemInfo** system_info) {
+ MinidumpSystemInfo* minidump_system_info = dump->GetSystemInfo();
if (!minidump_system_info)
return NULL;
@@ -520,15 +520,15 @@
}
// static
-bool MinidumpProcessor::GetCPUInfo(Minidump *dump, SystemInfo *info) {
+bool MinidumpProcessor::GetCPUInfo(Minidump* dump, SystemInfo* info) {
assert(dump);
assert(info);
info->cpu.clear();
info->cpu_info.clear();
- MinidumpSystemInfo *system_info;
- const MDRawSystemInfo *raw_system_info = GetSystemInfo(dump, &system_info);
+ MinidumpSystemInfo* system_info;
+ const MDRawSystemInfo* raw_system_info = GetSystemInfo(dump, &system_info);
if (!raw_system_info)
return false;
@@ -541,7 +541,7 @@
else
info->cpu = "amd64";
- const string *cpu_vendor = system_info->GetCPUVendor();
+ const string* cpu_vendor = system_info->GetCPUVendor();
if (cpu_vendor) {
info->cpu_info = *cpu_vendor;
info->cpu_info.append(" ");
@@ -608,7 +608,7 @@
}
// static
-bool MinidumpProcessor::GetOSInfo(Minidump *dump, SystemInfo *info) {
+bool MinidumpProcessor::GetOSInfo(Minidump* dump, SystemInfo* info) {
assert(dump);
assert(info);
@@ -616,8 +616,8 @@
info->os_short.clear();
info->os_version.clear();
- MinidumpSystemInfo *system_info;
- const MDRawSystemInfo *raw_system_info = GetSystemInfo(dump, &system_info);
+ MinidumpSystemInfo* system_info;
+ const MDRawSystemInfo* raw_system_info = GetSystemInfo(dump, &system_info);
if (!raw_system_info)
return false;
@@ -691,7 +691,7 @@
raw_system_info->build_number);
info->os_version = os_version_string;
- const string *csd_version = system_info->GetCSDVersion();
+ const string* csd_version = system_info->GetCSDVersion();
if (csd_version) {
info->os_version.append(" ");
info->os_version.append(*csd_version);
@@ -727,12 +727,12 @@
}
// static
-string MinidumpProcessor::GetCrashReason(Minidump *dump, uint64_t *address) {
- MinidumpException *exception = dump->GetException();
+string MinidumpProcessor::GetCrashReason(Minidump* dump, uint64_t* address) {
+ MinidumpException* exception = dump->GetException();
if (!exception)
return "";
- const MDRawExceptionStream *raw_exception = exception->exception();
+ const MDRawExceptionStream* raw_exception = exception->exception();
if (!raw_exception)
return "";
@@ -752,7 +752,7 @@
flags_string);
string reason = reason_string;
- const MDRawSystemInfo *raw_system_info = GetSystemInfo(dump, NULL);
+ const MDRawSystemInfo* raw_system_info = GetSystemInfo(dump, NULL);
if (!raw_system_info)
return reason;
@@ -1743,12 +1743,12 @@
}
// static
-string MinidumpProcessor::GetAssertion(Minidump *dump) {
- MinidumpAssertion *assertion = dump->GetAssertion();
+string MinidumpProcessor::GetAssertion(Minidump* dump) {
+ MinidumpAssertion* assertion = dump->GetAssertion();
if (!assertion)
return "";
- const MDRawAssertionInfo *raw_assertion = assertion->assertion();
+ const MDRawAssertionInfo* raw_assertion = assertion->assertion();
if (!raw_assertion)
return "";
diff --git a/src/processor/minidump_processor_unittest.cc b/src/processor/minidump_processor_unittest.cc
index a4ac368..306c2f0 100644
--- a/src/processor/minidump_processor_unittest.cc
+++ b/src/processor/minidump_processor_unittest.cc
@@ -127,16 +127,16 @@
uint64_t GetBase() const { return region_.GetBase(); }
uint32_t GetSize() const { return region_.GetSize(); }
- bool GetMemoryAtAddress(uint64_t address, uint8_t *value) const {
+ bool GetMemoryAtAddress(uint64_t address, uint8_t* value) const {
return region_.GetMemoryAtAddress(address, value);
}
- bool GetMemoryAtAddress(uint64_t address, uint16_t *value) const {
+ bool GetMemoryAtAddress(uint64_t address, uint16_t* value) const {
return region_.GetMemoryAtAddress(address, value);
}
- bool GetMemoryAtAddress(uint64_t address, uint32_t *value) const {
+ bool GetMemoryAtAddress(uint64_t address, uint32_t* value) const {
return region_.GetMemoryAtAddress(address, value);
}
- bool GetMemoryAtAddress(uint64_t address, uint64_t *value) const {
+ bool GetMemoryAtAddress(uint64_t address, uint64_t* value) const {
return region_.GetMemoryAtAddress(address, value);
}
@@ -188,11 +188,11 @@
using ::testing::Return;
using ::testing::SetArgumentPointee;
-static const char *kSystemInfoOS = "Windows NT";
-static const char *kSystemInfoOSShort = "windows";
-static const char *kSystemInfoOSVersion = "5.1.2600 Service Pack 2";
-static const char *kSystemInfoCPU = "x86";
-static const char *kSystemInfoCPUInfo =
+static const char* kSystemInfoOS = "Windows NT";
+static const char* kSystemInfoOSShort = "windows";
+static const char* kSystemInfoOSVersion = "5.1.2600 Service Pack 2";
+static const char* kSystemInfoCPU = "x86";
+static const char* kSystemInfoCPUInfo =
"GenuineIntel family 6 model 13 stepping 8";
#define ASSERT_TRUE_ABORT(cond) \
@@ -204,7 +204,7 @@
#define ASSERT_EQ_ABORT(e1, e2) ASSERT_TRUE_ABORT((e1) == (e2))
static string GetTestDataPath() {
- char *srcdir = getenv("srcdir");
+ char* srcdir = getenv("srcdir");
return string(srcdir ? srcdir : ".") + "/src/processor/testdata/";
}
@@ -213,35 +213,35 @@
public:
TestSymbolSupplier() : interrupt_(false) {}
- virtual SymbolResult GetSymbolFile(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file);
+ virtual SymbolResult GetSymbolFile(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file);
- virtual SymbolResult GetSymbolFile(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file,
- string *symbol_data);
+ virtual SymbolResult GetSymbolFile(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file,
+ string* symbol_data);
- virtual SymbolResult GetCStringSymbolData(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file,
- char **symbol_data,
- size_t *symbol_data_size);
+ virtual SymbolResult GetCStringSymbolData(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file,
+ char** symbol_data,
+ size_t* symbol_data_size);
- virtual void FreeSymbolData(const CodeModule *module);
+ virtual void FreeSymbolData(const CodeModule* module);
// When set to true, causes the SymbolSupplier to return INTERRUPT
void set_interrupt(bool interrupt) { interrupt_ = interrupt; }
private:
bool interrupt_;
- map<string, char *> memory_buffers_;
+ map<string, char*> memory_buffers_;
};
SymbolSupplier::SymbolResult TestSymbolSupplier::GetSymbolFile(
- const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file) {
+ const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file) {
ASSERT_TRUE_ABORT(module);
ASSERT_TRUE_ABORT(system_info);
ASSERT_EQ_ABORT(system_info->cpu, kSystemInfoCPU);
@@ -264,10 +264,10 @@
}
SymbolSupplier::SymbolResult TestSymbolSupplier::GetSymbolFile(
- const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file,
- string *symbol_data) {
+ const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file,
+ string* symbol_data) {
SymbolSupplier::SymbolResult s = GetSymbolFile(module, system_info,
symbol_file);
if (s == FOUND) {
@@ -281,11 +281,11 @@
}
SymbolSupplier::SymbolResult TestSymbolSupplier::GetCStringSymbolData(
- const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file,
- char **symbol_data,
- size_t *symbol_data_size) {
+ const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file,
+ char** symbol_data,
+ size_t* symbol_data_size) {
string symbol_data_string;
SymbolSupplier::SymbolResult s = GetSymbolFile(module,
system_info,
@@ -307,8 +307,8 @@
return s;
}
-void TestSymbolSupplier::FreeSymbolData(const CodeModule *module) {
- map<string, char *>::iterator it = memory_buffers_.find(module->code_file());
+void TestSymbolSupplier::FreeSymbolData(const CodeModule* module) {
+ map<string, char*>::iterator it = memory_buffers_.find(module->code_file());
if (it != memory_buffers_.end()) {
delete [] it->second;
memory_buffers_.erase(it);
@@ -523,7 +523,7 @@
EXPECT_EQ(1171480435U, state.time_date_stamp());
EXPECT_EQ(1171480435U, state.process_create_time());
- CallStack *stack = state.threads()->at(0);
+ CallStack* stack = state.threads()->at(0);
ASSERT_TRUE(stack);
ASSERT_EQ(stack->frames()->size(), 4U);
@@ -763,7 +763,7 @@
} // namespace
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
diff --git a/src/processor/minidump_stackwalk.cc b/src/processor/minidump_stackwalk.cc
index acf8097..aedd027 100644
--- a/src/processor/minidump_stackwalk.cc
+++ b/src/processor/minidump_stackwalk.cc
@@ -138,7 +138,7 @@
options->machine_readable = false;
options->output_stack_contents = false;
- while ((ch = getopt(argc, (char * const *)argv, "hms")) != -1) {
+ while ((ch = getopt(argc, (char * const*)argv, "hms")) != -1) {
switch (ch) {
case 'h':
Usage(argc, argv, false);
diff --git a/src/processor/minidump_unittest.cc b/src/processor/minidump_unittest.cc
index 036d03f..49b007f 100644
--- a/src/processor/minidump_unittest.cc
+++ b/src/processor/minidump_unittest.cc
@@ -95,9 +95,9 @@
ASSERT_NE(header, (MDRawHeader*)NULL);
ASSERT_EQ(header->signature, uint32_t(MD_HEADER_SIGNATURE));
- MinidumpModuleList *md_module_list = minidump.GetModuleList();
+ MinidumpModuleList* md_module_list = minidump.GetModuleList();
ASSERT_TRUE(md_module_list != NULL);
- const MinidumpModule *md_module = md_module_list->GetModuleAtIndex(0);
+ const MinidumpModule* md_module = md_module_list->GetModuleAtIndex(0);
ASSERT_TRUE(md_module != NULL);
ASSERT_EQ("c:\\test_app.exe", md_module->code_file());
ASSERT_EQ("c:\\test_app.pdb", md_module->debug_file());
@@ -167,7 +167,7 @@
ASSERT_TRUE(minidump.Read());
ASSERT_EQ(1U, minidump.GetDirectoryEntryCount());
- const MDRawDirectory *dir = minidump.GetDirectoryEntryAtIndex(0);
+ const MDRawDirectory* dir = minidump.GetDirectoryEntryAtIndex(0);
ASSERT_TRUE(dir != NULL);
EXPECT_EQ(0xfbb7fa2bU, dir->stream_type);
@@ -203,18 +203,18 @@
ASSERT_TRUE(minidump.Read());
ASSERT_EQ(1U, minidump.GetDirectoryEntryCount());
- const MDRawDirectory *dir = minidump.GetDirectoryEntryAtIndex(0);
+ const MDRawDirectory* dir = minidump.GetDirectoryEntryAtIndex(0);
ASSERT_TRUE(dir != NULL);
EXPECT_EQ((uint32_t) MD_MEMORY_LIST_STREAM, dir->stream_type);
- MinidumpMemoryList *memory_list = minidump.GetMemoryList();
+ MinidumpMemoryList* memory_list = minidump.GetMemoryList();
ASSERT_TRUE(memory_list != NULL);
ASSERT_EQ(1U, memory_list->region_count());
- MinidumpMemoryRegion *region1 = memory_list->GetMemoryRegionAtIndex(0);
+ MinidumpMemoryRegion* region1 = memory_list->GetMemoryRegionAtIndex(0);
ASSERT_EQ(0x309d68010bd21b2cULL, region1->GetBase());
ASSERT_EQ(15U, region1->GetSize());
- const uint8_t *region1_bytes = region1->GetMemory();
+ const uint8_t* region1_bytes = region1->GetMemory();
ASSERT_TRUE(memcmp("memory contents", region1_bytes, 15) == 0);
}
@@ -257,33 +257,33 @@
ASSERT_TRUE(minidump.Read());
ASSERT_EQ(2U, minidump.GetDirectoryEntryCount());
- MinidumpMemoryList *md_memory_list = minidump.GetMemoryList();
+ MinidumpMemoryList* md_memory_list = minidump.GetMemoryList();
ASSERT_TRUE(md_memory_list != NULL);
ASSERT_EQ(1U, md_memory_list->region_count());
- MinidumpMemoryRegion *md_region = md_memory_list->GetMemoryRegionAtIndex(0);
+ MinidumpMemoryRegion* md_region = md_memory_list->GetMemoryRegionAtIndex(0);
ASSERT_EQ(0x2326a0faU, md_region->GetBase());
ASSERT_EQ(16U, md_region->GetSize());
- const uint8_t *region_bytes = md_region->GetMemory();
+ const uint8_t* region_bytes = md_region->GetMemory();
ASSERT_TRUE(memcmp("stack for thread", region_bytes, 16) == 0);
- MinidumpThreadList *thread_list = minidump.GetThreadList();
+ MinidumpThreadList* thread_list = minidump.GetThreadList();
ASSERT_TRUE(thread_list != NULL);
ASSERT_EQ(1U, thread_list->thread_count());
- MinidumpThread *md_thread = thread_list->GetThreadAtIndex(0);
+ MinidumpThread* md_thread = thread_list->GetThreadAtIndex(0);
ASSERT_TRUE(md_thread != NULL);
uint32_t thread_id;
ASSERT_TRUE(md_thread->GetThreadID(&thread_id));
ASSERT_EQ(0xa898f11bU, thread_id);
- MinidumpMemoryRegion *md_stack = md_thread->GetMemory();
+ MinidumpMemoryRegion* md_stack = md_thread->GetMemory();
ASSERT_TRUE(md_stack != NULL);
ASSERT_EQ(0x2326a0faU, md_stack->GetBase());
ASSERT_EQ(16U, md_stack->GetSize());
- const uint8_t *md_stack_bytes = md_stack->GetMemory();
+ const uint8_t* md_stack_bytes = md_stack->GetMemory();
ASSERT_TRUE(memcmp("stack for thread", md_stack_bytes, 16) == 0);
- MinidumpContext *md_context = md_thread->GetContext();
+ MinidumpContext* md_context = md_thread->GetContext();
ASSERT_TRUE(md_context != NULL);
ASSERT_EQ((uint32_t) MD_CONTEXT_X86, md_context->GetContextCPU());
@@ -291,7 +291,7 @@
ASSERT_TRUE(md_context->GetInstructionPointer(&eip));
EXPECT_EQ(kExpectedEIP, eip);
- const MDRawContextX86 *md_raw_context = md_context->GetContextX86();
+ const MDRawContextX86* md_raw_context = md_context->GetContextX86();
ASSERT_TRUE(md_raw_context != NULL);
ASSERT_EQ((uint32_t) (MD_CONTEXT_X86_INTEGER | MD_CONTEXT_X86_CONTROL),
(md_raw_context->context_flags
@@ -425,16 +425,16 @@
ASSERT_TRUE(minidump.Read());
ASSERT_EQ(2U, minidump.GetDirectoryEntryCount());
- const MDRawDirectory *dir = minidump.GetDirectoryEntryAtIndex(1);
+ const MDRawDirectory* dir = minidump.GetDirectoryEntryAtIndex(1);
ASSERT_TRUE(dir != NULL);
EXPECT_EQ((uint32_t) MD_UNLOADED_MODULE_LIST_STREAM, dir->stream_type);
- MinidumpUnloadedModuleList *md_unloaded_module_list =
+ MinidumpUnloadedModuleList* md_unloaded_module_list =
minidump.GetUnloadedModuleList();
ASSERT_TRUE(md_unloaded_module_list != NULL);
ASSERT_EQ(1U, md_unloaded_module_list->module_count());
- const MinidumpUnloadedModule *md_unloaded_module =
+ const MinidumpUnloadedModule* md_unloaded_module =
md_unloaded_module_list->GetModuleAtIndex(0);
ASSERT_TRUE(md_unloaded_module != NULL);
ASSERT_EQ(0xa90206ca83eb2852ULL, md_unloaded_module->base_address());
@@ -445,7 +445,7 @@
ASSERT_EQ("B1054D2Aada542bd", md_unloaded_module->code_identifier());
ASSERT_EQ("", md_unloaded_module->debug_identifier());
- const MDRawUnloadedModule *md_raw_unloaded_module =
+ const MDRawUnloadedModule* md_raw_unloaded_module =
md_unloaded_module->module();
ASSERT_TRUE(md_raw_unloaded_module != NULL);
ASSERT_EQ(0xb1054d2aU, md_raw_unloaded_module->time_date_stamp);
@@ -506,15 +506,15 @@
ASSERT_TRUE(minidump.Read());
ASSERT_EQ(2U, minidump.GetDirectoryEntryCount());
- const MDRawDirectory *dir = minidump.GetDirectoryEntryAtIndex(1);
+ const MDRawDirectory* dir = minidump.GetDirectoryEntryAtIndex(1);
ASSERT_TRUE(dir != NULL);
EXPECT_EQ((uint32_t) MD_MODULE_LIST_STREAM, dir->stream_type);
- MinidumpModuleList *md_module_list = minidump.GetModuleList();
+ MinidumpModuleList* md_module_list = minidump.GetModuleList();
ASSERT_TRUE(md_module_list != NULL);
ASSERT_EQ(1U, md_module_list->module_count());
- const MinidumpModule *md_module = md_module_list->GetModuleAtIndex(0);
+ const MinidumpModule* md_module = md_module_list->GetModuleAtIndex(0);
ASSERT_TRUE(md_module != NULL);
ASSERT_EQ(0xa90206ca83eb2852ULL, md_module->base_address());
ASSERT_EQ(0xada542bd, md_module->size());
@@ -524,7 +524,7 @@
ASSERT_EQ("B1054D2Aada542bd", md_module->code_identifier());
ASSERT_EQ("ABCD1234F00DBEEF01020304050607081", md_module->debug_identifier());
- const MDRawModule *md_raw_module = md_module->module();
+ const MDRawModule* md_raw_module = md_module->module();
ASSERT_TRUE(md_raw_module != NULL);
ASSERT_EQ(0xb1054d2aU, md_raw_module->time_date_stamp);
ASSERT_EQ(0x34571371U, md_raw_module->checksum);
@@ -588,11 +588,11 @@
Minidump minidump(minidump_stream);
ASSERT_TRUE(minidump.Read());
- MinidumpModuleList *md_module_list = minidump.GetModuleList();
+ MinidumpModuleList* md_module_list = minidump.GetModuleList();
ASSERT_TRUE(md_module_list != NULL);
ASSERT_EQ(1U, md_module_list->module_count());
- const MinidumpModule *md_module = md_module_list->GetModuleAtIndex(0);
+ const MinidumpModule* md_module = md_module_list->GetModuleAtIndex(0);
ASSERT_TRUE(md_module != NULL);
ASSERT_EQ(0xa90206ca83eb2852ULL, md_module->base_address());
ASSERT_EQ(0xada542bd, md_module->size());
@@ -606,7 +606,7 @@
// age appended
ASSERT_EQ("B4CDA95F53101BDF86FAB733B4DF37380", md_module->debug_identifier());
- const MDRawModule *md_raw_module = md_module->module();
+ const MDRawModule* md_raw_module = md_module->module();
ASSERT_TRUE(md_raw_module != NULL);
ASSERT_EQ(0xb1054d2aU, md_raw_module->time_date_stamp);
ASSERT_EQ(0x34571371U, md_raw_module->checksum);
@@ -670,11 +670,11 @@
ASSERT_TRUE(minidump.Read());
ASSERT_EQ(2U, minidump.GetDirectoryEntryCount());
- MinidumpModuleList *md_module_list = minidump.GetModuleList();
+ MinidumpModuleList* md_module_list = minidump.GetModuleList();
ASSERT_TRUE(md_module_list != NULL);
ASSERT_EQ(1U, md_module_list->module_count());
- const MinidumpModule *md_module = md_module_list->GetModuleAtIndex(0);
+ const MinidumpModule* md_module = md_module_list->GetModuleAtIndex(0);
ASSERT_TRUE(md_module != NULL);
// just the build_id, directly
ASSERT_EQ("5fa9cdb4", md_module->code_identifier());
@@ -742,11 +742,11 @@
ASSERT_TRUE(minidump.Read());
ASSERT_EQ(2U, minidump.GetDirectoryEntryCount());
- MinidumpModuleList *md_module_list = minidump.GetModuleList();
+ MinidumpModuleList* md_module_list = minidump.GetModuleList();
ASSERT_TRUE(md_module_list != NULL);
ASSERT_EQ(1U, md_module_list->module_count());
- const MinidumpModule *md_module = md_module_list->GetModuleAtIndex(0);
+ const MinidumpModule* md_module = md_module_list->GetModuleAtIndex(0);
ASSERT_TRUE(md_module != NULL);
// just the build_id, directly
ASSERT_EQ(
@@ -773,11 +773,11 @@
ASSERT_TRUE(minidump.Read());
ASSERT_EQ(1U, minidump.GetDirectoryEntryCount());
- const MDRawDirectory *dir = minidump.GetDirectoryEntryAtIndex(0);
+ const MDRawDirectory* dir = minidump.GetDirectoryEntryAtIndex(0);
ASSERT_TRUE(dir != NULL);
EXPECT_EQ((uint32_t) MD_SYSTEM_INFO_STREAM, dir->stream_type);
- MinidumpSystemInfo *md_system_info = minidump.GetSystemInfo();
+ MinidumpSystemInfo* md_system_info = minidump.GetSystemInfo();
ASSERT_TRUE(md_system_info != NULL);
ASSERT_EQ("windows", md_system_info->GetOS());
ASSERT_EQ("x86", md_system_info->GetCPU());
@@ -912,7 +912,7 @@
ASSERT_EQ(5U, minidump.GetDirectoryEntryCount());
// Check the threads.
- MinidumpThreadList *thread_list = minidump.GetThreadList();
+ MinidumpThreadList* thread_list = minidump.GetThreadList();
ASSERT_TRUE(thread_list != NULL);
ASSERT_EQ(5U, thread_list->thread_count());
uint32_t thread_id;
@@ -957,7 +957,7 @@
->eip);
// Check the modules.
- MinidumpModuleList *md_module_list = minidump.GetModuleList();
+ MinidumpModuleList* md_module_list = minidump.GetModuleList();
ASSERT_TRUE(md_module_list != NULL);
ASSERT_EQ(3U, md_module_list->module_count());
EXPECT_EQ(0xeb77da57b5d4cbdaULL,
@@ -968,7 +968,7 @@
md_module_list->GetModuleAtIndex(2)->base_address());
// Check unloaded modules
- MinidumpUnloadedModuleList *md_unloaded_module_list =
+ MinidumpUnloadedModuleList* md_unloaded_module_list =
minidump.GetUnloadedModuleList();
ASSERT_TRUE(md_unloaded_module_list != NULL);
ASSERT_EQ(3U, md_unloaded_module_list->module_count());
@@ -979,7 +979,7 @@
EXPECT_EQ(umodule3_base,
md_unloaded_module_list->GetModuleAtIndex(2)->base_address());
- const MinidumpUnloadedModule *umodule =
+ const MinidumpUnloadedModule* umodule =
md_unloaded_module_list->GetModuleForAddress(
umodule1_base + umodule1_size / 2);
EXPECT_EQ(umodule1_base, umodule->base_address());
@@ -1025,22 +1025,22 @@
ASSERT_TRUE(minidump.Read());
ASSERT_EQ(1U, minidump.GetDirectoryEntryCount());
- const MDRawDirectory *dir = minidump.GetDirectoryEntryAtIndex(0);
+ const MDRawDirectory* dir = minidump.GetDirectoryEntryAtIndex(0);
ASSERT_TRUE(dir != NULL);
EXPECT_EQ((uint32_t) MD_MEMORY_INFO_LIST_STREAM, dir->stream_type);
- MinidumpMemoryInfoList *info_list = minidump.GetMemoryInfoList();
+ MinidumpMemoryInfoList* info_list = minidump.GetMemoryInfoList();
ASSERT_TRUE(info_list != NULL);
ASSERT_EQ(1U, info_list->info_count());
- const MinidumpMemoryInfo *info1 = info_list->GetMemoryInfoAtIndex(0);
+ const MinidumpMemoryInfo* info1 = info_list->GetMemoryInfoAtIndex(0);
ASSERT_EQ(kBaseAddress, info1->GetBase());
ASSERT_EQ(kRegionSize, info1->GetSize());
ASSERT_TRUE(info1->IsExecutable());
ASSERT_TRUE(info1->IsWritable());
// Should get back the same memory region here.
- const MinidumpMemoryInfo *info2 =
+ const MinidumpMemoryInfo* info2 =
info_list->GetMemoryInfoForAddress(kBaseAddress + kRegionSize / 2);
ASSERT_EQ(kBaseAddress, info2->GetBase());
ASSERT_EQ(kRegionSize, info2->GetSize());
@@ -1083,7 +1083,7 @@
ASSERT_TRUE(minidump.Read());
ASSERT_EQ(1U, minidump.GetDirectoryEntryCount());
- MinidumpException *md_exception = minidump.GetException();
+ MinidumpException* md_exception = minidump.GetException();
ASSERT_TRUE(md_exception != NULL);
uint32_t thread_id;
@@ -1097,10 +1097,10 @@
EXPECT_EQ(0x0919a9b9c9d9e9f9ULL,
raw_exception->exception_record.exception_address);
- MinidumpContext *md_context = md_exception->GetContext();
+ MinidumpContext* md_context = md_exception->GetContext();
ASSERT_TRUE(md_context != NULL);
ASSERT_EQ((uint32_t) MD_CONTEXT_X86, md_context->GetContextCPU());
- const MDRawContextX86 *md_raw_context = md_context->GetContextX86();
+ const MDRawContextX86* md_raw_context = md_context->GetContextX86();
ASSERT_TRUE(md_raw_context != NULL);
ASSERT_EQ((uint32_t) (MD_CONTEXT_X86_INTEGER | MD_CONTEXT_X86_CONTROL),
(md_raw_context->context_flags
@@ -1157,7 +1157,7 @@
ASSERT_TRUE(minidump.Read());
ASSERT_EQ(1U, minidump.GetDirectoryEntryCount());
- MinidumpException *md_exception = minidump.GetException();
+ MinidumpException* md_exception = minidump.GetException();
ASSERT_TRUE(md_exception != NULL);
uint32_t thread_id;
@@ -1171,10 +1171,10 @@
EXPECT_EQ(0x0919a9b9c9d9e9f9ULL,
raw_exception->exception_record.exception_address);
- MinidumpContext *md_context = md_exception->GetContext();
+ MinidumpContext* md_context = md_exception->GetContext();
ASSERT_TRUE(md_context != NULL);
ASSERT_EQ((uint32_t) MD_CONTEXT_X86, md_context->GetContextCPU());
- const MDRawContextX86 *md_raw_context = md_context->GetContextX86();
+ const MDRawContextX86* md_raw_context = md_context->GetContextX86();
ASSERT_TRUE(md_raw_context != NULL);
ASSERT_EQ((uint32_t) (MD_CONTEXT_X86_INTEGER | MD_CONTEXT_X86_CONTROL),
(md_raw_context->context_flags
@@ -1242,7 +1242,7 @@
ASSERT_TRUE(minidump.Read());
ASSERT_EQ(2U, minidump.GetDirectoryEntryCount());
- MinidumpException *md_exception = minidump.GetException();
+ MinidumpException* md_exception = minidump.GetException();
ASSERT_TRUE(md_exception != NULL);
uint32_t thread_id;
@@ -1256,11 +1256,11 @@
EXPECT_EQ(0x0919a9b9c9d9e9f9ULL,
raw_exception->exception_record.exception_address);
- MinidumpContext *md_context = md_exception->GetContext();
+ MinidumpContext* md_context = md_exception->GetContext();
ASSERT_TRUE(md_context != NULL);
ASSERT_EQ((uint32_t) MD_CONTEXT_X86, md_context->GetContextCPU());
- const MDRawContextX86 *md_raw_context = md_context->GetContextX86();
+ const MDRawContextX86* md_raw_context = md_context->GetContextX86();
ASSERT_TRUE(md_raw_context != NULL);
// Even though the CPU flags were missing from the context_flags, the
@@ -1324,7 +1324,7 @@
ASSERT_TRUE(minidump.Read());
ASSERT_EQ(1U, minidump.GetDirectoryEntryCount());
- MinidumpException *md_exception = minidump.GetException();
+ MinidumpException* md_exception = minidump.GetException();
ASSERT_TRUE(md_exception != NULL);
uint32_t thread_id;
@@ -1341,7 +1341,7 @@
// The context record of the exception is unusable because the context_flags
// don't have CPU type information and at the same time the minidump lacks
// system info stream so it is impossible to deduce the CPU type.
- MinidumpContext *md_context = md_exception->GetContext();
+ MinidumpContext* md_context = md_exception->GetContext();
ASSERT_EQ(NULL, md_context);
}
@@ -1387,7 +1387,7 @@
ASSERT_TRUE(minidump.Read());
ASSERT_EQ(1U, minidump.GetDirectoryEntryCount());
- MinidumpException *md_exception = minidump.GetException();
+ MinidumpException* md_exception = minidump.GetException();
ASSERT_TRUE(md_exception != NULL);
uint32_t thread_id;
@@ -1401,10 +1401,10 @@
EXPECT_EQ(0x0919a9b9c9d9e9f9ULL,
raw_exception->exception_record.exception_address);
- MinidumpContext *md_context = md_exception->GetContext();
+ MinidumpContext* md_context = md_exception->GetContext();
ASSERT_TRUE(md_context != NULL);
ASSERT_EQ((uint32_t) MD_CONTEXT_ARM, md_context->GetContextCPU());
- const MDRawContextARM *md_raw_context = md_context->GetContextARM();
+ const MDRawContextARM* md_raw_context = md_context->GetContextARM();
ASSERT_TRUE(md_raw_context != NULL);
ASSERT_EQ((uint32_t) MD_CONTEXT_ARM_INTEGER,
(md_raw_context->context_flags
@@ -1471,7 +1471,7 @@
ASSERT_TRUE(minidump.Read());
ASSERT_EQ(1U, minidump.GetDirectoryEntryCount());
- MinidumpException *md_exception = minidump.GetException();
+ MinidumpException* md_exception = minidump.GetException();
ASSERT_TRUE(md_exception != NULL);
uint32_t thread_id;
@@ -1485,10 +1485,10 @@
EXPECT_EQ(0x0919a9b9c9d9e9f9ULL,
raw_exception->exception_record.exception_address);
- MinidumpContext *md_context = md_exception->GetContext();
+ MinidumpContext* md_context = md_exception->GetContext();
ASSERT_TRUE(md_context != NULL);
ASSERT_EQ((uint32_t) MD_CONTEXT_ARM, md_context->GetContextCPU());
- const MDRawContextARM *md_raw_context = md_context->GetContextARM();
+ const MDRawContextARM* md_raw_context = md_context->GetContextARM();
ASSERT_TRUE(md_raw_context != NULL);
ASSERT_EQ((uint32_t) MD_CONTEXT_ARM_INTEGER,
(md_raw_context->context_flags
@@ -1570,7 +1570,7 @@
ASSERT_TRUE(minidump.Read());
ASSERT_EQ(1U, minidump.GetDirectoryEntryCount());
- MinidumpException *md_exception = minidump.GetException();
+ MinidumpException* md_exception = minidump.GetException();
ASSERT_TRUE(md_exception != NULL);
uint32_t thread_id;
diff --git a/src/processor/module_comparer.cc b/src/processor/module_comparer.cc
index 025ab88..669f113 100644
--- a/src/processor/module_comparer.cc
+++ b/src/processor/module_comparer.cc
@@ -52,7 +52,7 @@
namespace google_breakpad {
-bool ModuleComparer::Compare(const string &symbol_data) {
+bool ModuleComparer::Compare(const string& symbol_data) {
scoped_ptr<BasicModule> basic_module(new BasicModule("test_module"));
scoped_ptr<FastModule> fast_module(new FastModule("test_module"));
@@ -284,7 +284,7 @@
while (iter1 != basic_crm->map_->end()
&& iter2 != fast_crm->map_.end()) {
ASSERT_TRUE(iter1->first == iter2.GetKey());
- StaticContainedRangeMap<MemAddr, char> *child =
+ StaticContainedRangeMap<MemAddr, char>* child =
new StaticContainedRangeMap<MemAddr, char>(
reinterpret_cast<const char*>(iter2.GetValuePtr()));
ASSERT_TRUE(CompareCRM(iter1->second, child));
diff --git a/src/processor/module_comparer.h b/src/processor/module_comparer.h
index fcbd517..3691081 100644
--- a/src/processor/module_comparer.h
+++ b/src/processor/module_comparer.h
@@ -64,7 +64,7 @@
// FastSourceLineResolver loads its module using the serialized memory chunk,
// Then, traverse both modules together and compare underlying data
// return true if both modules contain exactly same data.
- bool Compare(const string &symbol_data);
+ bool Compare(const string& symbol_data);
private:
typedef BasicSourceLineResolver::Module BasicModule;
diff --git a/src/processor/module_factory.h b/src/processor/module_factory.h
index 7aa7caa..c6465f4 100644
--- a/src/processor/module_factory.h
+++ b/src/processor/module_factory.h
@@ -46,14 +46,14 @@
public:
virtual ~ModuleFactory() { };
virtual SourceLineResolverBase::Module* CreateModule(
- const string &name) const = 0;
+ const string& name) const = 0;
};
class BasicModuleFactory : public ModuleFactory {
public:
virtual ~BasicModuleFactory() { }
virtual BasicSourceLineResolver::Module* CreateModule(
- const string &name) const {
+ const string& name) const {
return new BasicSourceLineResolver::Module(name);
}
};
@@ -62,7 +62,7 @@
public:
virtual ~FastModuleFactory() { }
virtual FastSourceLineResolver::Module* CreateModule(
- const string &name) const {
+ const string& name) const {
return new FastSourceLineResolver::Module(name);
}
};
diff --git a/src/processor/module_serializer.cc b/src/processor/module_serializer.cc
index 6ac60c1..04cadc8 100644
--- a/src/processor/module_serializer.cc
+++ b/src/processor/module_serializer.cc
@@ -48,7 +48,7 @@
RangeMapSerializer< MemAddr, linked_ptr<BasicSourceLineResolver::Line> >
SimpleSerializer<BasicSourceLineResolver::Function>::range_map_serializer_;
-size_t ModuleSerializer::SizeOf(const BasicSourceLineResolver::Module &module) {
+size_t ModuleSerializer::SizeOf(const BasicSourceLineResolver::Module& module) {
size_t total_size_alloc_ = 0;
// Size of the "is_corrupt" flag.
@@ -80,8 +80,8 @@
return total_size_alloc_;
}
-char *ModuleSerializer::Write(const BasicSourceLineResolver::Module &module,
- char *dest) {
+char* ModuleSerializer::Write(const BasicSourceLineResolver::Module& module,
+ char* dest) {
// Write the is_corrupt flag.
dest = SimpleSerializer<bool>::Write(module.is_corrupt_, dest);
// Write header.
@@ -101,12 +101,12 @@
}
char* ModuleSerializer::Serialize(
- const BasicSourceLineResolver::Module &module, unsigned int *size) {
+ const BasicSourceLineResolver::Module& module, unsigned int* size) {
// Compute size of memory to allocate.
unsigned int size_to_alloc = SizeOf(module);
// Allocate memory for serialized data.
- char *serialized_data = new char[size_to_alloc];
+ char* serialized_data = new char[size_to_alloc];
if (!serialized_data) {
BPLOG(ERROR) << "ModuleSerializer: memory allocation failed, "
<< "size to alloc: " << size_to_alloc;
@@ -115,7 +115,7 @@
}
// Write serialized data to allocated memory chunk.
- char *end_address = Write(module, serialized_data);
+ char* end_address = Write(module, serialized_data);
// Verify the allocated memory size is equal to the size of data been written.
unsigned int size_written =
static_cast<unsigned int>(end_address - serialized_data);
@@ -131,8 +131,8 @@
}
bool ModuleSerializer::SerializeModuleAndLoadIntoFastResolver(
- const BasicSourceLineResolver::ModuleMap::const_iterator &iter,
- FastSourceLineResolver *fast_resolver) {
+ const BasicSourceLineResolver::ModuleMap::const_iterator& iter,
+ FastSourceLineResolver* fast_resolver) {
BPLOG(INFO) << "Converting symbol " << iter->first.c_str();
// Cast SourceLineResolverBase::Module* to BasicSourceLineResolver::Module*.
@@ -161,8 +161,8 @@
}
void ModuleSerializer::ConvertAllModules(
- const BasicSourceLineResolver *basic_resolver,
- FastSourceLineResolver *fast_resolver) {
+ const BasicSourceLineResolver* basic_resolver,
+ FastSourceLineResolver* fast_resolver) {
// Check for NULL pointer.
if (!basic_resolver || !fast_resolver)
return;
@@ -175,9 +175,9 @@
}
bool ModuleSerializer::ConvertOneModule(
- const string &moduleid,
- const BasicSourceLineResolver *basic_resolver,
- FastSourceLineResolver *fast_resolver) {
+ const string& moduleid,
+ const BasicSourceLineResolver* basic_resolver,
+ FastSourceLineResolver* fast_resolver) {
// Check for NULL pointer.
if (!basic_resolver || !fast_resolver)
return false;
@@ -191,7 +191,7 @@
}
char* ModuleSerializer::SerializeSymbolFileData(
- const string &symbol_data, unsigned int *size) {
+ const string& symbol_data, unsigned int* size) {
scoped_ptr<BasicSourceLineResolver::Module> module(
new BasicSourceLineResolver::Module("no name"));
scoped_array<char> buffer(new char[symbol_data.size() + 1]);
diff --git a/src/processor/module_serializer.h b/src/processor/module_serializer.h
index effb009..932ac3d 100644
--- a/src/processor/module_serializer.h
+++ b/src/processor/module_serializer.h
@@ -61,38 +61,38 @@
public:
// Compute the size of memory required to serialize a module. Return the
// total size needed for serialization.
- size_t SizeOf(const BasicSourceLineResolver::Module &module);
+ size_t SizeOf(const BasicSourceLineResolver::Module& module);
// Write a module into an allocated memory chunk with required size.
// Return the "end" of data, i.e., the address after the final byte of data.
- char* Write(const BasicSourceLineResolver::Module &module, char *dest);
+ char* Write(const BasicSourceLineResolver::Module& module, char* dest);
// Serializes a loaded Module object into a chunk of memory data and returns
// the address of memory chunk. If size != NULL, *size is set to the memory
// size allocated for the serialized data.
// Caller takes the ownership of the memory chunk (allocated on heap), and
// owner should call delete [] to free the memory after use.
- char* Serialize(const BasicSourceLineResolver::Module &module,
- unsigned int *size = NULL);
+ char* Serialize(const BasicSourceLineResolver::Module& module,
+ unsigned int* size = NULL);
// Given the string format symbol_data, produces a chunk of serialized data.
// Caller takes ownership of the serialized data (on heap), and owner should
// call delete [] to free the memory after use.
- char* SerializeSymbolFileData(const string &symbol_data,
- unsigned int *size = NULL);
+ char* SerializeSymbolFileData(const string& symbol_data,
+ unsigned int* size = NULL);
// Serializes one loaded module with given moduleid in the basic source line
// resolver, and loads the serialized data into the fast source line resolver.
// Return false if the basic source line doesn't have a module with the given
// moduleid.
- bool ConvertOneModule(const string &moduleid,
- const BasicSourceLineResolver *basic_resolver,
- FastSourceLineResolver *fast_resolver);
+ bool ConvertOneModule(const string& moduleid,
+ const BasicSourceLineResolver* basic_resolver,
+ FastSourceLineResolver* fast_resolver);
// Serializes all the loaded modules in a basic source line resolver, and
// loads the serialized data into a fast source line resolver.
- void ConvertAllModules(const BasicSourceLineResolver *basic_resolver,
- FastSourceLineResolver *fast_resolver);
+ void ConvertAllModules(const BasicSourceLineResolver* basic_resolver,
+ FastSourceLineResolver* fast_resolver);
private:
// Convenient type names.
@@ -102,8 +102,8 @@
// Internal implementation for ConvertOneModule and ConvertAllModules methods.
bool SerializeModuleAndLoadIntoFastResolver(
- const BasicSourceLineResolver::ModuleMap::const_iterator &iter,
- FastSourceLineResolver *fast_resolver);
+ const BasicSourceLineResolver::ModuleMap::const_iterator& iter,
+ FastSourceLineResolver* fast_resolver);
// Number of Maps that Module class contains.
static const int32_t kNumberMaps_ =
diff --git a/src/processor/pathname_stripper.cc b/src/processor/pathname_stripper.cc
index 839287b..c425b46 100644
--- a/src/processor/pathname_stripper.cc
+++ b/src/processor/pathname_stripper.cc
@@ -38,7 +38,7 @@
namespace google_breakpad {
// static
-string PathnameStripper::File(const string &path) {
+string PathnameStripper::File(const string& path) {
string::size_type slash = path.rfind('/');
string::size_type backslash = path.rfind('\\');
diff --git a/src/processor/pathname_stripper.h b/src/processor/pathname_stripper.h
index 423ca0d..fdf15e0 100644
--- a/src/processor/pathname_stripper.h
+++ b/src/processor/pathname_stripper.h
@@ -45,7 +45,7 @@
// Given path, a pathname with components separated by slashes (/) or
// backslashes (\), returns the trailing component, without any separator.
// If path ends in a separator character, returns an empty string.
- static string File(const string &path);
+ static string File(const string& path);
};
} // namespace google_breakpad
diff --git a/src/processor/pathname_stripper_unittest.cc b/src/processor/pathname_stripper_unittest.cc
index 1bff4cb..61f74fa 100644
--- a/src/processor/pathname_stripper_unittest.cc
+++ b/src/processor/pathname_stripper_unittest.cc
@@ -80,7 +80,7 @@
} // namespace
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
BPLOG_INIT(&argc, &argv);
return RunTests() ? 0 : 1;
diff --git a/src/processor/postfix_evaluator-inl.h b/src/processor/postfix_evaluator-inl.h
index d7dbeac..f567b1c 100644
--- a/src/processor/postfix_evaluator-inl.h
+++ b/src/processor/postfix_evaluator-inl.h
@@ -58,19 +58,19 @@
// before returning failure.
class AutoStackClearer {
public:
- explicit AutoStackClearer(vector<string> *stack) : stack_(stack) {}
+ explicit AutoStackClearer(vector<string>* stack) : stack_(stack) {}
~AutoStackClearer() { stack_->clear(); }
private:
- vector<string> *stack_;
+ vector<string>* stack_;
};
template<typename ValueType>
bool PostfixEvaluator<ValueType>::EvaluateToken(
- const string &token,
- const string &expression,
- DictionaryValidityType *assigned) {
+ const string& token,
+ const string& expression,
+ DictionaryValidityType* assigned) {
// There are enough binary operations that do exactly the same thing
// (other than the specific operation, of course) that it makes sense
// to share as much code as possible.
@@ -203,8 +203,8 @@
template<typename ValueType>
bool PostfixEvaluator<ValueType>::EvaluateInternal(
- const string &expression,
- DictionaryValidityType *assigned) {
+ const string& expression,
+ DictionaryValidityType* assigned) {
// Tokenize, splitting on whitespace.
istringstream stream(expression);
string token;
@@ -231,8 +231,8 @@
}
template<typename ValueType>
-bool PostfixEvaluator<ValueType>::Evaluate(const string &expression,
- DictionaryValidityType *assigned) {
+bool PostfixEvaluator<ValueType>::Evaluate(const string& expression,
+ DictionaryValidityType* assigned) {
// Ensure that the stack is cleared before returning.
AutoStackClearer clearer(&stack_);
@@ -250,8 +250,8 @@
}
template<typename ValueType>
-bool PostfixEvaluator<ValueType>::EvaluateForValue(const string &expression,
- ValueType *result) {
+bool PostfixEvaluator<ValueType>::EvaluateForValue(const string& expression,
+ ValueType* result) {
// Ensure that the stack is cleared before returning.
AutoStackClearer clearer(&stack_);
@@ -271,7 +271,7 @@
template<typename ValueType>
typename PostfixEvaluator<ValueType>::PopResult
PostfixEvaluator<ValueType>::PopValueOrIdentifier(
- ValueType *value, string *identifier) {
+ ValueType* value, string* identifier) {
// There needs to be at least one element on the stack to pop.
if (!stack_.size())
return POP_RESULT_FAIL;
@@ -314,7 +314,7 @@
template<typename ValueType>
-bool PostfixEvaluator<ValueType>::PopValue(ValueType *value) {
+bool PostfixEvaluator<ValueType>::PopValue(ValueType* value) {
ValueType literal = ValueType();
string token;
PopResult result;
@@ -343,14 +343,14 @@
template<typename ValueType>
-bool PostfixEvaluator<ValueType>::PopValues(ValueType *value1,
- ValueType *value2) {
+bool PostfixEvaluator<ValueType>::PopValues(ValueType* value1,
+ ValueType* value2) {
return PopValue(value2) && PopValue(value1);
}
template<typename ValueType>
-void PostfixEvaluator<ValueType>::PushValue(const ValueType &value) {
+void PostfixEvaluator<ValueType>::PushValue(const ValueType& value) {
ostringstream token_stream;
token_stream << value;
stack_.push_back(token_stream.str());
diff --git a/src/processor/postfix_evaluator.h b/src/processor/postfix_evaluator.h
index 94b6619..d847a9b 100644
--- a/src/processor/postfix_evaluator.h
+++ b/src/processor/postfix_evaluator.h
@@ -95,7 +95,7 @@
// (^) will not be supported. |dictionary| may be NULL, but evaluation
// will fail in that case unless set_dictionary is used before calling
// Evaluate.
- PostfixEvaluator(DictionaryType *dictionary, const MemoryRegion *memory)
+ PostfixEvaluator(DictionaryType* dictionary, const MemoryRegion* memory)
: dictionary_(dictionary), memory_(memory), stack_() {}
// Evaluate the expression, starting with an empty stack. The results of
@@ -105,18 +105,18 @@
// non-NULL, any keys set in the dictionary as a result of evaluation
// will also be set to true in assigned, providing a way to determine if
// an expression modifies any of its input variables.
- bool Evaluate(const string &expression, DictionaryValidityType *assigned);
+ bool Evaluate(const string& expression, DictionaryValidityType* assigned);
// Like Evaluate, but provides the value left on the stack to the
// caller. If evaluation succeeds and leaves exactly one value on
// the stack, pop that value, store it in *result, and return true.
// Otherwise, return false.
- bool EvaluateForValue(const string &expression, ValueType *result);
+ bool EvaluateForValue(const string& expression, ValueType* result);
DictionaryType* dictionary() const { return dictionary_; }
// Reset the dictionary. PostfixEvaluator does not take ownership.
- void set_dictionary(DictionaryType *dictionary) {dictionary_ = dictionary; }
+ void set_dictionary(DictionaryType* dictionary) {dictionary_ = dictionary; }
private:
// Return values for PopValueOrIdentifier
@@ -132,40 +132,40 @@
// if the topmost entry is a constant or variable identifier, and sets
// |identifier| accordingly. Returns POP_RESULT_FAIL on failure, such
// as when the stack is empty.
- PopResult PopValueOrIdentifier(ValueType *value, string *identifier);
+ PopResult PopValueOrIdentifier(ValueType* value, string* identifier);
// Retrieves the topmost value on the stack. If the topmost entry is
// an identifier, the dictionary is queried for the identifier's value.
// Returns false on failure, such as when the stack is empty or when
// a nonexistent identifier is named.
- bool PopValue(ValueType *value);
+ bool PopValue(ValueType* value);
// Retrieves the top two values on the stack, in the style of PopValue.
// value2 is popped before value1, so that value1 corresponds to the
// entry that was pushed prior to value2. Returns false on failure.
- bool PopValues(ValueType *value1, ValueType *value2);
+ bool PopValues(ValueType* value1, ValueType* value2);
// Pushes a new value onto the stack.
- void PushValue(const ValueType &value);
+ void PushValue(const ValueType& value);
// Evaluate expression, updating *assigned if it is non-zero. Return
// true if evaluation completes successfully. Do not clear the stack
// upon successful evaluation.
- bool EvaluateInternal(const string &expression,
- DictionaryValidityType *assigned);
+ bool EvaluateInternal(const string& expression,
+ DictionaryValidityType* assigned);
- bool EvaluateToken(const string &token,
- const string &expression,
- DictionaryValidityType *assigned);
+ bool EvaluateToken(const string& token,
+ const string& expression,
+ DictionaryValidityType* assigned);
// The dictionary mapping constant and variable identifiers (strings) to
// values. Keys beginning with '$' are treated as variable names, and
// PostfixEvaluator is free to create and modify these keys. Weak pointer.
- DictionaryType *dictionary_;
+ DictionaryType* dictionary_;
// If non-NULL, the MemoryRegion used for dereference (^) operations.
// If NULL, dereferencing is unsupported and will fail. Weak pointer.
- const MemoryRegion *memory_;
+ const MemoryRegion* memory_;
// The stack contains state information as execution progresses. Values
// are pushed on to it as the expression string is read and as operations
diff --git a/src/processor/postfix_evaluator_unittest.cc b/src/processor/postfix_evaluator_unittest.cc
index f118982..5a01584 100644
--- a/src/processor/postfix_evaluator_unittest.cc
+++ b/src/processor/postfix_evaluator_unittest.cc
@@ -60,19 +60,19 @@
public:
virtual uint64_t GetBase() const { return 0; }
virtual uint32_t GetSize() const { return 0; }
- virtual bool GetMemoryAtAddress(uint64_t address, uint8_t *value) const {
+ virtual bool GetMemoryAtAddress(uint64_t address, uint8_t* value) const {
*value = address + 1;
return true;
}
- virtual bool GetMemoryAtAddress(uint64_t address, uint16_t *value) const {
+ virtual bool GetMemoryAtAddress(uint64_t address, uint16_t* value) const {
*value = address + 1;
return true;
}
- virtual bool GetMemoryAtAddress(uint64_t address, uint32_t *value) const {
+ virtual bool GetMemoryAtAddress(uint64_t address, uint32_t* value) const {
*value = address + 1;
return true;
}
- virtual bool GetMemoryAtAddress(uint64_t address, uint64_t *value) const {
+ virtual bool GetMemoryAtAddress(uint64_t address, uint64_t* value) const {
*value = address + 1;
return true;
}
@@ -94,17 +94,17 @@
struct EvaluateTestSet {
// The dictionary used for all tests in the set.
- PostfixEvaluator<unsigned int>::DictionaryType *dictionary;
+ PostfixEvaluator<unsigned int>::DictionaryType* dictionary;
// The list of tests.
- const EvaluateTest *evaluate_tests;
+ const EvaluateTest* evaluate_tests;
// The number of tests.
unsigned int evaluate_test_count;
// Identifiers and their expected values upon completion of the Evaluate
// tests in the set.
- map<string, unsigned int> *validate_data;
+ map<string, unsigned int>* validate_data;
};
@@ -227,9 +227,9 @@
for (unsigned int evaluate_test_set_index = 0;
evaluate_test_set_index < evaluate_test_set_count;
++evaluate_test_set_index) {
- EvaluateTestSet *evaluate_test_set =
+ EvaluateTestSet* evaluate_test_set =
&evaluate_test_sets[evaluate_test_set_index];
- const EvaluateTest *evaluate_tests = evaluate_test_set->evaluate_tests;
+ const EvaluateTest* evaluate_tests = evaluate_test_set->evaluate_tests;
unsigned int evaluate_test_count = evaluate_test_set->evaluate_test_count;
// The same dictionary will be used for each test in the set. Earlier
@@ -242,7 +242,7 @@
for (unsigned int evaluate_test_index = 0;
evaluate_test_index < evaluate_test_count;
++evaluate_test_index) {
- const EvaluateTest *evaluate_test = &evaluate_tests[evaluate_test_index];
+ const EvaluateTest* evaluate_test = &evaluate_tests[evaluate_test_index];
// Do the test.
bool result = postfix_evaluator.Evaluate(evaluate_test->expression,
@@ -344,7 +344,7 @@
postfix_evaluator.set_dictionary(&dictionary_2);
for (int i = 0; i < evaluate_for_value_tests_2_size; i++) {
- const EvaluateForValueTest *test = &evaluate_for_value_tests_2[i];
+ const EvaluateForValueTest* test = &evaluate_for_value_tests_2[i];
unsigned int result;
if (postfix_evaluator.EvaluateForValue(test->expression, &result)
!= test->evaluable) {
@@ -396,7 +396,7 @@
} // namespace
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
BPLOG_INIT(&argc, &argv);
return RunTests() ? 0 : 1;
diff --git a/src/processor/process_state.cc b/src/processor/process_state.cc
index 43c4a4b..c9269e4 100644
--- a/src/processor/process_state.cc
+++ b/src/processor/process_state.cc
@@ -51,7 +51,7 @@
crash_address_ = 0;
assertion_.clear();
requesting_thread_ = -1;
- for (vector<CallStack *>::const_iterator iterator = threads_.begin();
+ for (vector<CallStack*>::const_iterator iterator = threads_.begin();
iterator != threads_.end();
++iterator) {
delete *iterator;
diff --git a/src/processor/range_map-inl.h b/src/processor/range_map-inl.h
index 4d3b0eb..6bfc725 100644
--- a/src/processor/range_map-inl.h
+++ b/src/processor/range_map-inl.h
@@ -47,16 +47,16 @@
namespace google_breakpad {
template<typename AddressType, typename EntryType>
-bool RangeMap<AddressType, EntryType>::StoreRange(const AddressType &base,
- const AddressType &size,
- const EntryType &entry) {
+bool RangeMap<AddressType, EntryType>::StoreRange(const AddressType& base,
+ const AddressType& size,
+ const EntryType& entry) {
return StoreRangeInternal(base, 0 /* delta */, size, entry);
}
template<typename AddressType, typename EntryType>
bool RangeMap<AddressType, EntryType>::StoreRangeInternal(
- const AddressType &base, const AddressType &delta,
- const AddressType &size, const EntryType &entry) {
+ const AddressType& base, const AddressType& delta,
+ const AddressType& size, const EntryType& entry) {
AddressType high = base + (size - 1);
// Check for undersize or overflow.
@@ -181,8 +181,8 @@
template<typename AddressType, typename EntryType>
bool RangeMap<AddressType, EntryType>::RetrieveRange(
- const AddressType &address, EntryType *entry, AddressType *entry_base,
- AddressType *entry_delta, AddressType *entry_size) const {
+ const AddressType& address, EntryType* entry, AddressType* entry_base,
+ AddressType* entry_delta, AddressType* entry_size) const {
BPLOG_IF(ERROR, !entry) << "RangeMap::RetrieveRange requires |entry|";
assert(entry);
@@ -212,8 +212,8 @@
template<typename AddressType, typename EntryType>
bool RangeMap<AddressType, EntryType>::RetrieveNearestRange(
- const AddressType &address, EntryType *entry, AddressType *entry_base,
- AddressType *entry_delta, AddressType *entry_size) const {
+ const AddressType& address, EntryType* entry, AddressType* entry_base,
+ AddressType* entry_delta, AddressType* entry_size) const {
BPLOG_IF(ERROR, !entry) << "RangeMap::RetrieveNearestRange requires |entry|";
assert(entry);
@@ -245,8 +245,8 @@
template<typename AddressType, typename EntryType>
bool RangeMap<AddressType, EntryType>::RetrieveRangeAtIndex(
- int index, EntryType *entry, AddressType *entry_base,
- AddressType *entry_delta, AddressType *entry_size) const {
+ int index, EntryType* entry, AddressType* entry_base,
+ AddressType* entry_delta, AddressType* entry_size) const {
BPLOG_IF(ERROR, !entry) << "RangeMap::RetrieveRangeAtIndex requires |entry|";
assert(entry);
diff --git a/src/processor/range_map.h b/src/processor/range_map.h
index 33f3297..baea91c 100644
--- a/src/processor/range_map.h
+++ b/src/processor/range_map.h
@@ -78,17 +78,17 @@
// stored in the map. If enable_shrink_down is true and there is an overlap
// between the current range and some other range (already in the map),
// shrink down the range which ends at a higher address.
- bool StoreRange(const AddressType &base, const AddressType &size,
- const EntryType &entry);
+ bool StoreRange(const AddressType& base, const AddressType& size,
+ const EntryType& entry);
// Locates the range encompassing the supplied address. If there is no such
// range, returns false. entry_base, entry_delta, and entry_size, if
// non-NULL, are set to the base, delta, and size of the entry's range.
// A positive entry delta (> 0) indicates that there was an overlap and the
// entry was shrunk down (original start address was increased by delta).
- bool RetrieveRange(const AddressType &address, EntryType *entry,
- AddressType *entry_base, AddressType *entry_delta,
- AddressType *entry_size) const;
+ bool RetrieveRange(const AddressType& address, EntryType* entry,
+ AddressType* entry_base, AddressType* entry_delta,
+ AddressType* entry_size) const;
// Locates the range encompassing the supplied address, if one exists.
// If no range encompasses the supplied address, locates the nearest range
@@ -97,9 +97,9 @@
// if non-NULL, are set to the base, delta, and size of the entry's range.
// A positive entry delta (> 0) indicates that there was an overlap and the
// entry was shrunk down (original start address was increased by delta).
- bool RetrieveNearestRange(const AddressType &address, EntryType *entry,
- AddressType *entry_base, AddressType *entry_delta,
- AddressType *entry_size) const;
+ bool RetrieveNearestRange(const AddressType& address, EntryType* entry,
+ AddressType* entry_base, AddressType* entry_delta,
+ AddressType* entry_size) const;
// Treating all ranges as a list ordered by the address spaces that they
// occupy, locates the range at the index specified by index. Returns
@@ -110,9 +110,9 @@
// entry was shrunk down (original start address was increased by delta).
//
// RetrieveRangeAtIndex is not optimized for speedy operation.
- bool RetrieveRangeAtIndex(int index, EntryType *entry,
- AddressType *entry_base, AddressType *entry_delta,
- AddressType *entry_size) const;
+ bool RetrieveRangeAtIndex(int index, EntryType* entry,
+ AddressType* entry_base, AddressType* entry_delta,
+ AddressType* entry_size) const;
// Returns the number of ranges stored in the RangeMap.
int GetCount() const;
@@ -128,13 +128,13 @@
// Same a StoreRange() with the only exception that the |delta| can be
// passed in.
- bool StoreRangeInternal(const AddressType &base, const AddressType &delta,
- const AddressType &size, const EntryType &entry);
+ bool StoreRangeInternal(const AddressType& base, const AddressType& delta,
+ const AddressType& size, const EntryType& entry);
class Range {
public:
- Range(const AddressType &base, const AddressType &delta,
- const EntryType &entry)
+ Range(const AddressType& base, const AddressType& delta,
+ const EntryType& entry)
: base_(base), delta_(delta), entry_(entry) {}
AddressType base() const { return base_; }
diff --git a/src/processor/range_map_unittest.cc b/src/processor/range_map_unittest.cc
index 31b89e5..0f1c713 100644
--- a/src/processor/range_map_unittest.cc
+++ b/src/processor/range_map_unittest.cc
@@ -92,7 +92,7 @@
// sequence on the same RangeMap.
struct RangeTestSet {
// An array of RangeTests
- const RangeTest *range_tests;
+ const RangeTest* range_tests;
// The number of tests in the set
unsigned int range_test_count;
@@ -102,7 +102,7 @@
// StoreTest uses the data in a RangeTest and calls StoreRange on the
// test RangeMap. It returns true if the expected result occurred, and
// false if something else happened.
-static bool StoreTest(TestMap *range_map, const RangeTest *range_test) {
+static bool StoreTest(TestMap* range_map, const RangeTest* range_test) {
linked_ptr<CountedObject> object(new CountedObject(range_test->id));
bool stored = range_map->StoreRange(range_test->address,
range_test->size,
@@ -126,7 +126,7 @@
// map entry at the specified range,) it returns true, otherwise, it returns
// false. RetrieveTest will check the values around the base address and
// the high address of a range to guard against off-by-one errors.
-static bool RetrieveTest(TestMap *range_map, const RangeTest *range_test) {
+static bool RetrieveTest(TestMap* range_map, const RangeTest* range_test) {
for (unsigned int side = 0; side <= 1; ++side) {
// When side == 0, check the low side (base address) of each range.
// When side == 1, check the high side (base + size) of each range.
@@ -270,9 +270,9 @@
// and verifying that each call returns a different object than the previous
// call, and that ranges are returned with increasing base addresses. Returns
// false if the test fails.
-static bool RetrieveIndexTest(TestMap *range_map, int set) {
+static bool RetrieveIndexTest(TestMap* range_map, int set) {
linked_ptr<CountedObject> object;
- CountedObject *last_object = NULL;
+ CountedObject* last_object = NULL;
AddressType last_base = 0;
int object_count = range_map->GetCount();
@@ -469,7 +469,7 @@
for (unsigned int range_test_set_index = 0;
range_test_set_index < range_test_set_count;
++range_test_set_index) {
- const RangeTest *range_tests =
+ const RangeTest* range_tests =
range_test_sets[range_test_set_index].range_tests;
unsigned int range_test_count =
range_test_sets[range_test_set_index].range_test_count;
@@ -480,7 +480,7 @@
for (unsigned int range_test_index = 0;
range_test_index < range_test_count;
++range_test_index) {
- const RangeTest *range_test = &range_tests[range_test_index];
+ const RangeTest* range_test = &range_tests[range_test_index];
if (!StoreTest(range_map.get(), range_test))
return false;
@@ -512,7 +512,7 @@
for (unsigned int range_test_index = 0;
range_test_index < range_test_count;
++range_test_index) {
- const RangeTest *range_test = &range_tests[range_test_index];
+ const RangeTest* range_test = &range_tests[range_test_index];
if (!RetrieveTest(range_map.get(), range_test))
return false;
}
@@ -552,7 +552,7 @@
} // namespace
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
BPLOG_INIT(&argc, &argv);
return RunTests() ? 0 : 1;
diff --git a/src/processor/simple_serializer-inl.h b/src/processor/simple_serializer-inl.h
index 606bb3c..cb1a040 100644
--- a/src/processor/simple_serializer-inl.h
+++ b/src/processor/simple_serializer-inl.h
@@ -56,12 +56,12 @@
public:
static size_t SizeOf(bool boolean) { return 1; }
- static char *Write(bool boolean, char *dest) {
+ static char* Write(bool boolean, char* dest) {
*dest = static_cast<char>(boolean? 255 : 0);
return ++dest;
}
- static const char *Read(const char *source, bool *value) {
+ static const char* Read(const char* source, bool* value) {
*value = ((*source) == 0 ? false : true);
return ++source;
}
@@ -71,9 +71,9 @@
template<>
class SimpleSerializer<string> {
public:
- static size_t SizeOf(const string &str) { return str.size() + 1; }
+ static size_t SizeOf(const string& str) { return str.size() + 1; }
- static char *Write(const string &str, char *dest) {
+ static char* Write(const string& str, char* dest) {
strcpy(dest, str.c_str());
return dest + SizeOf(str);
}
@@ -83,11 +83,11 @@
template<>
class SimpleSerializer<const char*> {
public:
- static size_t SizeOf(const char *cstring) {
+ static size_t SizeOf(const char* cstring) {
return strlen(cstring) + 1;
}
- static char *Write(const char *cstring, char *dest) {
+ static char* Write(const char* cstring, char* dest) {
strcpy(dest, cstring);
return dest + SizeOf(cstring);
}
@@ -98,13 +98,13 @@
class SimpleSerializer<BasicSourceLineResolver::Line> {
typedef BasicSourceLineResolver::Line Line;
public:
- static size_t SizeOf(const Line &line) {
+ static size_t SizeOf(const Line& line) {
return SimpleSerializer<MemAddr>::SizeOf(line.address)
+ SimpleSerializer<MemAddr>::SizeOf(line.size)
+ SimpleSerializer<int32_t>::SizeOf(line.source_file_id)
+ SimpleSerializer<int32_t>::SizeOf(line.line);
}
- static char *Write(const Line &line, char *dest) {
+ static char* Write(const Line& line, char* dest) {
dest = SimpleSerializer<MemAddr>::Write(line.address, dest);
dest = SimpleSerializer<MemAddr>::Write(line.size, dest);
dest = SimpleSerializer<int32_t>::Write(line.source_file_id, dest);
@@ -118,12 +118,12 @@
class SimpleSerializer<BasicSourceLineResolver::PublicSymbol> {
typedef BasicSourceLineResolver::PublicSymbol PublicSymbol;
public:
- static size_t SizeOf(const PublicSymbol &pubsymbol) {
+ static size_t SizeOf(const PublicSymbol& pubsymbol) {
return SimpleSerializer<string>::SizeOf(pubsymbol.name)
+ SimpleSerializer<MemAddr>::SizeOf(pubsymbol.address)
+ SimpleSerializer<int32_t>::SizeOf(pubsymbol.parameter_size);
}
- static char *Write(const PublicSymbol &pubsymbol, char *dest) {
+ static char* Write(const PublicSymbol& pubsymbol, char* dest) {
dest = SimpleSerializer<string>::Write(pubsymbol.name, dest);
dest = SimpleSerializer<MemAddr>::Write(pubsymbol.address, dest);
dest = SimpleSerializer<int32_t>::Write(pubsymbol.parameter_size, dest);
@@ -135,7 +135,7 @@
template<>
class SimpleSerializer<WindowsFrameInfo> {
public:
- static size_t SizeOf(const WindowsFrameInfo &wfi) {
+ static size_t SizeOf(const WindowsFrameInfo& wfi) {
unsigned int size = 0;
size += sizeof(int32_t); // wfi.type_
size += SimpleSerializer<int32_t>::SizeOf(wfi.valid);
@@ -149,7 +149,7 @@
size += SimpleSerializer<string>::SizeOf(wfi.program_string);
return size;
}
- static char *Write(const WindowsFrameInfo &wfi, char *dest) {
+ static char* Write(const WindowsFrameInfo& wfi, char* dest) {
dest = SimpleSerializer<int32_t>::Write(
static_cast<const int32_t>(wfi.type_), dest);
dest = SimpleSerializer<int32_t>::Write(wfi.valid, dest);
@@ -170,11 +170,11 @@
class SimpleSerializer< linked_ptr<BasicSourceLineResolver::Line> > {
typedef BasicSourceLineResolver::Line Line;
public:
- static size_t SizeOf(const linked_ptr<Line> &lineptr) {
+ static size_t SizeOf(const linked_ptr<Line>& lineptr) {
if (lineptr.get() == NULL) return 0;
return SimpleSerializer<Line>::SizeOf(*(lineptr.get()));
}
- static char *Write(const linked_ptr<Line> &lineptr, char *dest) {
+ static char* Write(const linked_ptr<Line>& lineptr, char* dest) {
if (lineptr.get())
dest = SimpleSerializer<Line>::Write(*(lineptr.get()), dest);
return dest;
@@ -187,7 +187,7 @@
typedef BasicSourceLineResolver::Function Function;
typedef BasicSourceLineResolver::Line Line;
public:
- static size_t SizeOf(const Function &func) {
+ static size_t SizeOf(const Function& func) {
unsigned int size = 0;
size += SimpleSerializer<string>::SizeOf(func.name);
size += SimpleSerializer<MemAddr>::SizeOf(func.address);
@@ -197,7 +197,7 @@
return size;
}
- static char *Write(const Function &func, char *dest) {
+ static char* Write(const Function& func, char* dest) {
dest = SimpleSerializer<string>::Write(func.name, dest);
dest = SimpleSerializer<MemAddr>::Write(func.address, dest);
dest = SimpleSerializer<MemAddr>::Write(func.size, dest);
@@ -214,12 +214,12 @@
class SimpleSerializer< linked_ptr<BasicSourceLineResolver::Function> > {
typedef BasicSourceLineResolver::Function Function;
public:
- static size_t SizeOf(const linked_ptr<Function> &func) {
+ static size_t SizeOf(const linked_ptr<Function>& func) {
if (!func.get()) return 0;
return SimpleSerializer<Function>::SizeOf(*(func.get()));
}
- static char *Write(const linked_ptr<Function> &func, char *dest) {
+ static char* Write(const linked_ptr<Function>& func, char* dest) {
if (func.get())
dest = SimpleSerializer<Function>::Write(*(func.get()), dest);
return dest;
@@ -230,11 +230,11 @@
class SimpleSerializer< linked_ptr<BasicSourceLineResolver::PublicSymbol> > {
typedef BasicSourceLineResolver::PublicSymbol PublicSymbol;
public:
- static size_t SizeOf(const linked_ptr<PublicSymbol> &pubsymbol) {
+ static size_t SizeOf(const linked_ptr<PublicSymbol>& pubsymbol) {
if (pubsymbol.get() == NULL) return 0;
return SimpleSerializer<PublicSymbol>::SizeOf(*(pubsymbol.get()));
}
- static char *Write(const linked_ptr<PublicSymbol> &pubsymbol, char *dest) {
+ static char* Write(const linked_ptr<PublicSymbol>& pubsymbol, char* dest) {
if (pubsymbol.get())
dest = SimpleSerializer<PublicSymbol>::Write(*(pubsymbol.get()), dest);
return dest;
@@ -244,11 +244,11 @@
template<>
class SimpleSerializer< linked_ptr<WindowsFrameInfo> > {
public:
- static size_t SizeOf(const linked_ptr<WindowsFrameInfo> &wfi) {
+ static size_t SizeOf(const linked_ptr<WindowsFrameInfo>& wfi) {
if (wfi.get() == NULL) return 0;
return SimpleSerializer<WindowsFrameInfo>::SizeOf(*(wfi.get()));
}
- static char *Write(const linked_ptr<WindowsFrameInfo> &wfi, char *dest) {
+ static char* Write(const linked_ptr<WindowsFrameInfo>& wfi, char* dest) {
if (wfi.get())
dest = SimpleSerializer<WindowsFrameInfo>::Write(*(wfi.get()), dest);
return dest;
diff --git a/src/processor/simple_serializer.h b/src/processor/simple_serializer.h
index 275f51c..9e51d80 100644
--- a/src/processor/simple_serializer.h
+++ b/src/processor/simple_serializer.h
@@ -49,10 +49,10 @@
template<class Type> class SimpleSerializer {
public:
// Calculate and return the size of the 'item'.
- static size_t SizeOf(const Type &item) { return sizeof(item); }
+ static size_t SizeOf(const Type& item) { return sizeof(item); }
// Write 'item' to memory location 'dest', and return to the "end" address of
// data written, i.e., the address after the final byte written.
- static char *Write(const Type &item, char *dest) {
+ static char* Write(const Type& item, char* dest) {
new (dest) Type(item);
return dest + SizeOf(item);
}
diff --git a/src/processor/simple_symbol_supplier.cc b/src/processor/simple_symbol_supplier.cc
index bc5ebb6..cdc3efb 100644
--- a/src/processor/simple_symbol_supplier.cc
+++ b/src/processor/simple_symbol_supplier.cc
@@ -52,14 +52,14 @@
namespace google_breakpad {
-static bool file_exists(const string &file_name) {
+static bool file_exists(const string& file_name) {
struct stat sb;
return stat(file_name.c_str(), &sb) == 0;
}
SymbolSupplier::SymbolResult SimpleSymbolSupplier::GetSymbolFile(
- const CodeModule *module, const SystemInfo *system_info,
- string *symbol_file) {
+ const CodeModule* module, const SystemInfo* system_info,
+ string* symbol_file) {
BPLOG_IF(ERROR, !symbol_file) << "SimpleSymbolSupplier::GetSymbolFile "
"requires |symbol_file|";
assert(symbol_file);
@@ -77,10 +77,10 @@
}
SymbolSupplier::SymbolResult SimpleSymbolSupplier::GetSymbolFile(
- const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file,
- string *symbol_data) {
+ const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file,
+ string* symbol_data) {
assert(symbol_data);
symbol_data->clear();
@@ -96,11 +96,11 @@
}
SymbolSupplier::SymbolResult SimpleSymbolSupplier::GetCStringSymbolData(
- const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file,
- char **symbol_data,
- size_t *symbol_data_size) {
+ const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file,
+ char** symbol_data,
+ size_t* symbol_data_size) {
assert(symbol_data);
assert(symbol_data_size);
@@ -123,13 +123,13 @@
return s;
}
-void SimpleSymbolSupplier::FreeSymbolData(const CodeModule *module) {
+void SimpleSymbolSupplier::FreeSymbolData(const CodeModule* module) {
if (!module) {
BPLOG(INFO) << "Cannot free symbol data buffer for NULL module";
return;
}
- map<string, char *>::iterator it = memory_buffers_.find(module->code_file());
+ map<string, char*>::iterator it = memory_buffers_.find(module->code_file());
if (it == memory_buffers_.end()) {
BPLOG(INFO) << "Cannot find symbol data buffer for module "
<< module->code_file();
@@ -140,8 +140,8 @@
}
SymbolSupplier::SymbolResult SimpleSymbolSupplier::GetSymbolFileAtPathFromRoot(
- const CodeModule *module, const SystemInfo *system_info,
- const string &root_path, string *symbol_file) {
+ const CodeModule* module, const SystemInfo* system_info,
+ const string& root_path, string* symbol_file) {
BPLOG_IF(ERROR, !symbol_file) << "SimpleSymbolSupplier::GetSymbolFileAtPath "
"requires |symbol_file|";
assert(symbol_file);
diff --git a/src/processor/simple_symbol_supplier.h b/src/processor/simple_symbol_supplier.h
index 0cde85c..3a65c7e 100644
--- a/src/processor/simple_symbol_supplier.h
+++ b/src/processor/simple_symbol_supplier.h
@@ -94,44 +94,44 @@
public:
// Creates a new SimpleSymbolSupplier, using path as the root path where
// symbols are stored.
- explicit SimpleSymbolSupplier(const string &path) : paths_(1, path) {}
+ explicit SimpleSymbolSupplier(const string& path) : paths_(1, path) {}
// Creates a new SimpleSymbolSupplier, using paths as a list of root
// paths where symbols may be stored.
- explicit SimpleSymbolSupplier(const vector<string> &paths) : paths_(paths) {}
+ explicit SimpleSymbolSupplier(const vector<string>& paths) : paths_(paths) {}
virtual ~SimpleSymbolSupplier() {}
// Returns the path to the symbol file for the given module. See the
// description above.
- virtual SymbolResult GetSymbolFile(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file);
+ virtual SymbolResult GetSymbolFile(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file);
- virtual SymbolResult GetSymbolFile(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file,
- string *symbol_data);
+ virtual SymbolResult GetSymbolFile(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file,
+ string* symbol_data);
// Allocates data buffer on heap and writes symbol data into buffer.
// Symbol supplier ALWAYS takes ownership of the data buffer.
- virtual SymbolResult GetCStringSymbolData(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file,
- char **symbol_data,
- size_t *symbol_data_size);
+ virtual SymbolResult GetCStringSymbolData(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file,
+ char** symbol_data,
+ size_t* symbol_data_size);
// Free the data buffer allocated in the above GetCStringSymbolData();
- virtual void FreeSymbolData(const CodeModule *module);
+ virtual void FreeSymbolData(const CodeModule* module);
protected:
- SymbolResult GetSymbolFileAtPathFromRoot(const CodeModule *module,
- const SystemInfo *system_info,
- const string &root_path,
- string *symbol_file);
+ SymbolResult GetSymbolFileAtPathFromRoot(const CodeModule* module,
+ const SystemInfo* system_info,
+ const string& root_path,
+ string* symbol_file);
private:
- map<string, char *> memory_buffers_;
+ map<string, char*> memory_buffers_;
vector<string> paths_;
};
diff --git a/src/processor/source_line_resolver_base.cc b/src/processor/source_line_resolver_base.cc
index 6eff1f9..45a06cf 100644
--- a/src/processor/source_line_resolver_base.cc
+++ b/src/processor/source_line_resolver_base.cc
@@ -51,7 +51,7 @@
namespace google_breakpad {
SourceLineResolverBase::SourceLineResolverBase(
- ModuleFactory *module_factory)
+ ModuleFactory* module_factory)
: modules_(new ModuleMap),
corrupt_modules_(new ModuleSet),
memory_buffers_(new MemoryMap),
@@ -85,9 +85,9 @@
module_factory_ = NULL;
}
-bool SourceLineResolverBase::ReadSymbolFile(const string &map_file,
- char **symbol_data,
- size_t *symbol_data_size) {
+bool SourceLineResolverBase::ReadSymbolFile(const string& map_file,
+ char** symbol_data,
+ size_t* symbol_data_size) {
if (symbol_data == NULL || symbol_data_size == NULL) {
BPLOG(ERROR) << "Could not Read file into Null memory pointer";
return false;
@@ -117,7 +117,7 @@
BPLOG(INFO) << "Opening " << map_file;
- FILE *f = fopen(map_file.c_str(), "rt");
+ FILE* f = fopen(map_file.c_str(), "rt");
if (!f) {
string error_string;
error_code = ErrnoString(&error_string);
@@ -148,8 +148,8 @@
return true;
}
-bool SourceLineResolverBase::LoadModule(const CodeModule *module,
- const string &map_file) {
+bool SourceLineResolverBase::LoadModule(const CodeModule* module,
+ const string& map_file) {
if (module == NULL)
return false;
@@ -163,7 +163,7 @@
BPLOG(INFO) << "Loading symbols for module " << module->code_file()
<< " from " << map_file;
- char *memory_buffer;
+ char* memory_buffer;
size_t memory_buffer_size;
if (!ReadSymbolFile(map_file, &memory_buffer, &memory_buffer_size))
return false;
@@ -184,7 +184,7 @@
}
bool SourceLineResolverBase::LoadModuleUsingMapBuffer(
- const CodeModule *module, const string &map_buffer) {
+ const CodeModule* module, const string& map_buffer) {
if (module == NULL)
return false;
@@ -196,7 +196,7 @@
}
size_t memory_buffer_size = map_buffer.size() + 1;
- char *memory_buffer = new char[memory_buffer_size];
+ char* memory_buffer = new char[memory_buffer_size];
if (memory_buffer == NULL) {
BPLOG(ERROR) << "Could not allocate memory for " << module->code_file();
return false;
@@ -220,8 +220,8 @@
}
bool SourceLineResolverBase::LoadModuleUsingMemoryBuffer(
- const CodeModule *module,
- char *memory_buffer,
+ const CodeModule* module,
+ char* memory_buffer,
size_t memory_buffer_size) {
if (!module)
return false;
@@ -236,7 +236,7 @@
BPLOG(INFO) << "Loading symbols for module " << module->code_file()
<< " from memory buffer";
- Module *basic_module = module_factory_->CreateModule(module->code_file());
+ Module* basic_module = module_factory_->CreateModule(module->code_file());
// Ownership of memory is NOT transfered to Module::LoadMapFromMemory().
if (!basic_module->LoadMapFromMemory(memory_buffer, memory_buffer_size)) {
@@ -259,13 +259,13 @@
return true;
}
-void SourceLineResolverBase::UnloadModule(const CodeModule *code_module) {
+void SourceLineResolverBase::UnloadModule(const CodeModule* code_module) {
if (!code_module)
return;
ModuleMap::iterator mod_iter = modules_->find(code_module->code_file());
if (mod_iter != modules_->end()) {
- Module *symbol_module = mod_iter->second;
+ Module* symbol_module = mod_iter->second;
delete symbol_module;
corrupt_modules_->erase(mod_iter->first);
modules_->erase(mod_iter);
@@ -283,19 +283,19 @@
}
}
-bool SourceLineResolverBase::HasModule(const CodeModule *module) {
+bool SourceLineResolverBase::HasModule(const CodeModule* module) {
if (!module)
return false;
return modules_->find(module->code_file()) != modules_->end();
}
-bool SourceLineResolverBase::IsModuleCorrupt(const CodeModule *module) {
+bool SourceLineResolverBase::IsModuleCorrupt(const CodeModule* module) {
if (!module)
return false;
return corrupt_modules_->find(module->code_file()) != corrupt_modules_->end();
}
-void SourceLineResolverBase::FillSourceLineInfo(StackFrame *frame) {
+void SourceLineResolverBase::FillSourceLineInfo(StackFrame* frame) {
if (frame->module) {
ModuleMap::const_iterator it = modules_->find(frame->module->code_file());
if (it != modules_->end()) {
@@ -304,8 +304,8 @@
}
}
-WindowsFrameInfo *SourceLineResolverBase::FindWindowsFrameInfo(
- const StackFrame *frame) {
+WindowsFrameInfo* SourceLineResolverBase::FindWindowsFrameInfo(
+ const StackFrame* frame) {
if (frame->module) {
ModuleMap::const_iterator it = modules_->find(frame->module->code_file());
if (it != modules_->end()) {
@@ -315,8 +315,8 @@
return NULL;
}
-CFIFrameInfo *SourceLineResolverBase::FindCFIFrameInfo(
- const StackFrame *frame) {
+CFIFrameInfo* SourceLineResolverBase::FindCFIFrameInfo(
+ const StackFrame* frame) {
if (frame->module) {
ModuleMap::const_iterator it = modules_->find(frame->module->code_file());
if (it != modules_->end()) {
@@ -327,12 +327,12 @@
}
bool SourceLineResolverBase::CompareString::operator()(
- const string &s1, const string &s2) const {
+ const string& s1, const string& s2) const {
return strcmp(s1.c_str(), s2.c_str()) < 0;
}
bool SourceLineResolverBase::Module::ParseCFIRuleSet(
- const string &rule_set, CFIFrameInfo *frame_info) const {
+ const string& rule_set, CFIFrameInfo* frame_info) const {
CFIFrameInfoParseHandler handler(frame_info);
CFIRuleParser parser(&handler);
return parser.Parse(rule_set);
diff --git a/src/processor/source_line_resolver_base_types.h b/src/processor/source_line_resolver_base_types.h
index ca744e0..db9f7b8 100644
--- a/src/processor/source_line_resolver_base_types.h
+++ b/src/processor/source_line_resolver_base_types.h
@@ -56,14 +56,14 @@
class SourceLineResolverBase::AutoFileCloser {
public:
- explicit AutoFileCloser(FILE *file) : file_(file) {}
+ explicit AutoFileCloser(FILE* file) : file_(file) {}
~AutoFileCloser() {
if (file_)
fclose(file_);
}
private:
- FILE *file_;
+ FILE* file_;
};
struct SourceLineResolverBase::Line {
@@ -82,7 +82,7 @@
struct SourceLineResolverBase::Function {
Function() { }
- Function(const string &function_name,
+ Function(const string& function_name,
MemAddr function_address,
MemAddr code_size,
int set_parameter_size,
@@ -133,7 +133,7 @@
// The passed in |memory buffer| is of size |memory_buffer_size|. If it is
// not null terminated, LoadMapFromMemory will null terminate it by modifying
// the passed in buffer.
- virtual bool LoadMapFromMemory(char *memory_buffer,
+ virtual bool LoadMapFromMemory(char* memory_buffer,
size_t memory_buffer_size) = 0;
// Tells whether the loaded symbol data is corrupt. Return value is
@@ -142,24 +142,24 @@
// Looks up the given relative address, and fills the StackFrame struct
// with the result.
- virtual void LookupAddress(StackFrame *frame) const = 0;
+ virtual void LookupAddress(StackFrame* frame) const = 0;
// If Windows stack walking information is available covering ADDRESS,
// return a WindowsFrameInfo structure describing it. If the information
// is not available, returns NULL. A NULL return value does not indicate
// an error. The caller takes ownership of any returned WindowsFrameInfo
// object.
- virtual WindowsFrameInfo *
- FindWindowsFrameInfo(const StackFrame *frame) const = 0;
+ virtual WindowsFrameInfo*
+ FindWindowsFrameInfo(const StackFrame* frame) const = 0;
// If CFI stack walking information is available covering ADDRESS,
// return a CFIFrameInfo structure describing it. If the information
// is not available, return NULL. The caller takes ownership of any
// returned CFIFrameInfo object.
- virtual CFIFrameInfo *FindCFIFrameInfo(const StackFrame *frame) const = 0;
+ virtual CFIFrameInfo* FindCFIFrameInfo(const StackFrame* frame) const = 0;
protected:
- virtual bool ParseCFIRuleSet(const string &rule_set,
- CFIFrameInfo *frame_info) const;
+ virtual bool ParseCFIRuleSet(const string& rule_set,
+ CFIFrameInfo* frame_info) const;
};
} // namespace google_breakpad
diff --git a/src/processor/stackwalk_common.cc b/src/processor/stackwalk_common.cc
index 704039f..9047572 100644
--- a/src/processor/stackwalk_common.cc
+++ b/src/processor/stackwalk_common.cc
@@ -69,7 +69,7 @@
// of registers is completely printed, regardless of the number of calls
// to PrintRegister.
static const int kMaxWidth = 80; // optimize for an 80-column terminal
-static int PrintRegister(const char *name, uint32_t value, int start_col) {
+static int PrintRegister(const char* name, uint32_t value, int start_col) {
char buffer[64];
snprintf(buffer, sizeof(buffer), " %5s = 0x%08x", name, value);
@@ -83,7 +83,7 @@
}
// PrintRegister64 does the same thing, but for 64-bit registers.
-static int PrintRegister64(const char *name, uint64_t value, int start_col) {
+static int PrintRegister64(const char* name, uint64_t value, int start_col) {
char buffer[64];
snprintf(buffer, sizeof(buffer), " %5s = 0x%016" PRIx64 , name, value);
@@ -98,7 +98,7 @@
// StripSeparator takes a string |original| and returns a copy
// of the string with all occurences of |kOutputSeparator| removed.
-static string StripSeparator(const string &original) {
+static string StripSeparator(const string& original) {
string result = original;
string::size_type position = 0;
while ((position = result.find(kOutputSeparator, position)) != string::npos) {
@@ -112,20 +112,20 @@
}
// PrintStackContents prints the stack contents of the current frame to stdout.
-static void PrintStackContents(const string &indent,
- const StackFrame *frame,
- const StackFrame *prev_frame,
- const string &cpu,
- const MemoryRegion *memory,
+static void PrintStackContents(const string& indent,
+ const StackFrame* frame,
+ const StackFrame* prev_frame,
+ const string& cpu,
+ const MemoryRegion* memory,
const CodeModules* modules,
- SourceLineResolverInterface *resolver) {
+ SourceLineResolverInterface* resolver) {
// Find stack range.
int word_length = 0;
uint64_t stack_begin = 0, stack_end = 0;
if (cpu == "x86") {
word_length = 4;
- const StackFrameX86 *frame_x86 = static_cast<const StackFrameX86*>(frame);
- const StackFrameX86 *prev_frame_x86 =
+ const StackFrameX86* frame_x86 = static_cast<const StackFrameX86*>(frame);
+ const StackFrameX86* prev_frame_x86 =
static_cast<const StackFrameX86*>(prev_frame);
if ((frame_x86->context_validity & StackFrameX86::CONTEXT_VALID_ESP) &&
(prev_frame_x86->context_validity & StackFrameX86::CONTEXT_VALID_ESP)) {
@@ -134,9 +134,9 @@
}
} else if (cpu == "amd64") {
word_length = 8;
- const StackFrameAMD64 *frame_amd64 =
+ const StackFrameAMD64* frame_amd64 =
static_cast<const StackFrameAMD64*>(frame);
- const StackFrameAMD64 *prev_frame_amd64 =
+ const StackFrameAMD64* prev_frame_amd64 =
static_cast<const StackFrameAMD64*>(prev_frame);
if ((frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_RSP) &&
(prev_frame_amd64->context_validity &
@@ -146,8 +146,8 @@
}
} else if (cpu == "arm") {
word_length = 4;
- const StackFrameARM *frame_arm = static_cast<const StackFrameARM*>(frame);
- const StackFrameARM *prev_frame_arm =
+ const StackFrameARM* frame_arm = static_cast<const StackFrameARM*>(frame);
+ const StackFrameARM* prev_frame_arm =
static_cast<const StackFrameARM*>(prev_frame);
if ((frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_SP) &&
(prev_frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_SP)) {
@@ -156,9 +156,9 @@
}
} else if (cpu == "arm64") {
word_length = 8;
- const StackFrameARM64 *frame_arm64 =
+ const StackFrameARM64* frame_arm64 =
static_cast<const StackFrameARM64*>(frame);
- const StackFrameARM64 *prev_frame_arm64 =
+ const StackFrameARM64* prev_frame_arm64 =
static_cast<const StackFrameARM64*>(prev_frame);
if ((frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_SP) &&
(prev_frame_arm64->context_validity &
@@ -249,8 +249,8 @@
//
// If |cpu| is a recognized CPU name, relevant register state for each stack
// frame printed is also output, if available.
-static void PrintStack(const CallStack *stack,
- const string &cpu,
+static void PrintStack(const CallStack* stack,
+ const string& cpu,
bool output_stack_contents,
const MemoryRegion* memory,
const CodeModules* modules,
@@ -260,7 +260,7 @@
printf(" <no frames>\n");
}
for (int frame_index = 0; frame_index < frame_count; ++frame_index) {
- const StackFrame *frame = stack->frames()->at(frame_index);
+ const StackFrame* frame = stack->frames()->at(frame_index);
printf("%2d ", frame_index);
uint64_t instruction_address = frame->ReturnAddress();
@@ -289,7 +289,7 @@
int sequence = 0;
if (cpu == "x86") {
- const StackFrameX86 *frame_x86 =
+ const StackFrameX86* frame_x86 =
reinterpret_cast<const StackFrameX86*>(frame);
if (frame_x86->context_validity & StackFrameX86::CONTEXT_VALID_EIP)
@@ -311,7 +311,7 @@
sequence = PrintRegister("efl", frame_x86->context.eflags, sequence);
}
} else if (cpu == "ppc") {
- const StackFramePPC *frame_ppc =
+ const StackFramePPC* frame_ppc =
reinterpret_cast<const StackFramePPC*>(frame);
if (frame_ppc->context_validity & StackFramePPC::CONTEXT_VALID_SRR0)
@@ -319,7 +319,7 @@
if (frame_ppc->context_validity & StackFramePPC::CONTEXT_VALID_GPR1)
sequence = PrintRegister("r1", frame_ppc->context.gpr[1], sequence);
} else if (cpu == "amd64") {
- const StackFrameAMD64 *frame_amd64 =
+ const StackFrameAMD64* frame_amd64 =
reinterpret_cast<const StackFrameAMD64*>(frame);
if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_RAX)
@@ -357,7 +357,7 @@
if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_RIP)
sequence = PrintRegister64("rip", frame_amd64->context.rip, sequence);
} else if (cpu == "sparc") {
- const StackFrameSPARC *frame_sparc =
+ const StackFrameSPARC* frame_sparc =
reinterpret_cast<const StackFrameSPARC*>(frame);
if (frame_sparc->context_validity & StackFrameSPARC::CONTEXT_VALID_SP)
@@ -367,7 +367,7 @@
if (frame_sparc->context_validity & StackFrameSPARC::CONTEXT_VALID_PC)
sequence = PrintRegister("pc", frame_sparc->context.pc, sequence);
} else if (cpu == "arm") {
- const StackFrameARM *frame_arm =
+ const StackFrameARM* frame_arm =
reinterpret_cast<const StackFrameARM*>(frame);
// Argument registers (caller-saves), which will likely only be valid
@@ -409,7 +409,7 @@
if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_PC)
sequence = PrintRegister("pc", frame_arm->context.iregs[15], sequence);
} else if (cpu == "arm64") {
- const StackFrameARM64 *frame_arm64 =
+ const StackFrameARM64* frame_arm64 =
reinterpret_cast<const StackFrameARM64*>(frame);
if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X0) {
@@ -621,10 +621,10 @@
// Module, function, source file, and source line may all be empty
// depending on availability. The code offset follows the same rules as
// PrintStack above.
-static void PrintStackMachineReadable(int thread_num, const CallStack *stack) {
+static void PrintStackMachineReadable(int thread_num, const CallStack* stack) {
int frame_count = stack->frames()->size();
for (int frame_index = 0; frame_index < frame_count; ++frame_index) {
- const StackFrame *frame = stack->frames()->at(frame_index);
+ const StackFrame* frame = stack->frames()->at(frame_index);
printf("%d%c%d%c", thread_num, kOutputSeparator, frame_index,
kOutputSeparator);
@@ -676,8 +676,8 @@
// ContainsModule checks whether a given |module| is in the vector
// |modules_without_symbols|.
static bool ContainsModule(
- const vector<const CodeModule*> *modules,
- const CodeModule *module) {
+ const vector<const CodeModule*>* modules,
+ const CodeModule* module) {
assert(modules);
assert(module);
vector<const CodeModule*>::const_iterator iter;
@@ -694,9 +694,9 @@
// |modules_without_symbols| should contain the list of modules that were
// confirmed to be missing their symbols during the stack walk.
static void PrintModule(
- const CodeModule *module,
- const vector<const CodeModule*> *modules_without_symbols,
- const vector<const CodeModule*> *modules_with_corrupt_symbols,
+ const CodeModule* module,
+ const vector<const CodeModule*>* modules_without_symbols,
+ const vector<const CodeModule*>* modules_with_corrupt_symbols,
uint64_t main_address) {
string symbol_issues;
if (ContainsModule(modules_without_symbols, module)) {
@@ -721,9 +721,9 @@
// |modules_without_symbols| should contain the list of modules that were
// confirmed to be missing their symbols during the stack walk.
static void PrintModules(
- const CodeModules *modules,
- const vector<const CodeModule*> *modules_without_symbols,
- const vector<const CodeModule*> *modules_with_corrupt_symbols) {
+ const CodeModules* modules,
+ const vector<const CodeModule*>* modules_without_symbols,
+ const vector<const CodeModule*>* modules_with_corrupt_symbols) {
if (!modules)
return;
@@ -731,7 +731,7 @@
printf("Loaded modules:\n");
uint64_t main_address = 0;
- const CodeModule *main_module = modules->GetMainModule();
+ const CodeModule* main_module = modules->GetMainModule();
if (main_module) {
main_address = main_module->base_address();
}
@@ -740,7 +740,7 @@
for (unsigned int module_sequence = 0;
module_sequence < module_count;
++module_sequence) {
- const CodeModule *module = modules->GetModuleAtSequence(module_sequence);
+ const CodeModule* module = modules->GetModuleAtSequence(module_sequence);
PrintModule(module, modules_without_symbols, modules_with_corrupt_symbols,
main_address);
}
@@ -751,12 +751,12 @@
// text format:
// Module|{Module Filename}|{Version}|{Debug Filename}|{Debug Identifier}|
// {Base Address}|{Max Address}|{Main}
-static void PrintModulesMachineReadable(const CodeModules *modules) {
+static void PrintModulesMachineReadable(const CodeModules* modules) {
if (!modules)
return;
uint64_t main_address = 0;
- const CodeModule *main_module = modules->GetMainModule();
+ const CodeModule* main_module = modules->GetMainModule();
if (main_module) {
main_address = main_module->base_address();
}
@@ -765,7 +765,7 @@
for (unsigned int module_sequence = 0;
module_sequence < module_count;
++module_sequence) {
- const CodeModule *module = modules->GetModuleAtSequence(module_sequence);
+ const CodeModule* module = modules->GetModuleAtSequence(module_sequence);
uint64_t base_address = module->base_address();
printf("Module%c%s%c%s%c%s%c%s%c0x%08" PRIx64 "%c0x%08" PRIx64 "%c%d\n",
kOutputSeparator,
diff --git a/src/processor/stackwalker_address_list_unittest.cc b/src/processor/stackwalker_address_list_unittest.cc
index ab4e9c0..b09137d 100644
--- a/src/processor/stackwalker_address_list_unittest.cc
+++ b/src/processor/stackwalker_address_list_unittest.cc
@@ -94,9 +94,9 @@
// Set the Breakpad symbol information that supplier should return for
// MODULE to INFO.
- void SetModuleSymbols(MockCodeModule *module, const string &info) {
+ void SetModuleSymbols(MockCodeModule* module, const string& info) {
size_t buffer_size;
- char *buffer = supplier.CopySymbolDataAndOwnTheCopy(info, &buffer_size);
+ char* buffer = supplier.CopySymbolDataAndOwnTheCopy(info, &buffer_size);
EXPECT_CALL(supplier, GetCStringSymbolData(module, NULL, _, _, _))
.WillRepeatedly(DoAll(SetArgumentPointee<3>(buffer),
SetArgumentPointee<4>(buffer_size),
diff --git a/src/processor/stackwalker_amd64.cc b/src/processor/stackwalker_amd64.cc
index d5ac6c6..f906f20 100644
--- a/src/processor/stackwalker_amd64.cc
+++ b/src/processor/stackwalker_amd64.cc
@@ -126,7 +126,7 @@
}
StackFrameAMD64* StackwalkerAMD64::GetCallerByCFIFrameInfo(
- const vector<StackFrame*> &frames,
+ const vector<StackFrame*>& frames,
CFIFrameInfo* cfi_frame_info) {
StackFrameAMD64* last_frame = static_cast<StackFrameAMD64*>(frames.back());
@@ -217,7 +217,7 @@
}
StackFrameAMD64* StackwalkerAMD64::GetCallerByStackScan(
- const vector<StackFrame*> &frames) {
+ const vector<StackFrame*>& frames) {
StackFrameAMD64* last_frame = static_cast<StackFrameAMD64*>(frames.back());
uint64_t last_rsp = last_frame->context.rsp;
uint64_t caller_rip_address, caller_rip;
@@ -273,7 +273,7 @@
return NULL;
}
- const vector<StackFrame*> &frames = *stack->frames();
+ const vector<StackFrame*>& frames = *stack->frames();
StackFrameAMD64* last_frame = static_cast<StackFrameAMD64*>(frames.back());
scoped_ptr<StackFrameAMD64> new_frame;
diff --git a/src/processor/stackwalker_amd64.h b/src/processor/stackwalker_amd64.h
index 8f3dbd5..5e1af6f 100644
--- a/src/processor/stackwalker_amd64.h
+++ b/src/processor/stackwalker_amd64.h
@@ -75,7 +75,7 @@
// Use cfi_frame_info (derived from STACK CFI records) to construct
// the frame that called frames.back(). The caller takes ownership
// of the returned frame. Return NULL on failure.
- StackFrameAMD64* GetCallerByCFIFrameInfo(const vector<StackFrame*> &frames,
+ StackFrameAMD64* GetCallerByCFIFrameInfo(const vector<StackFrame*>& frames,
CFIFrameInfo* cfi_frame_info);
// Assumes a traditional frame layout where the frame pointer has not been
@@ -88,7 +88,7 @@
// Scan the stack for plausible return addresses. The caller takes ownership
// of the returned frame. Return NULL on failure.
- StackFrameAMD64* GetCallerByStackScan(const vector<StackFrame*> &frames);
+ StackFrameAMD64* GetCallerByStackScan(const vector<StackFrame*>& frames);
// Stores the CPU context corresponding to the innermost stack frame to
// be returned by GetContextFrame.
diff --git a/src/processor/stackwalker_amd64_unittest.cc b/src/processor/stackwalker_amd64_unittest.cc
index efcd812..a77015a 100644
--- a/src/processor/stackwalker_amd64_unittest.cc
+++ b/src/processor/stackwalker_amd64_unittest.cc
@@ -104,7 +104,7 @@
// Set the Breakpad symbol information that supplier should return for
// MODULE to INFO.
- void SetModuleSymbols(MockCodeModule *module, const string &info) {
+ void SetModuleSymbols(MockCodeModule* module, const string& info) {
size_t buffer_size;
char *buffer = supplier.CopySymbolDataAndOwnTheCopy(info, &buffer_size);
EXPECT_CALL(supplier, GetCStringSymbolData(module, &system_info, _, _, _))
@@ -125,7 +125,7 @@
void BrandContext(MDRawContextAMD64 *raw_context) {
uint8_t x = 173;
for (size_t i = 0; i < sizeof(*raw_context); i++)
- reinterpret_cast<uint8_t *>(raw_context)[i] = (x += 17);
+ reinterpret_cast<uint8_t*>(raw_context)[i] = (x += 17);
}
SystemInfo system_info;
@@ -138,7 +138,7 @@
MockSymbolSupplier supplier;
BasicSourceLineResolver resolver;
CallStack call_stack;
- const vector<StackFrame *> *frames;
+ const vector<StackFrame*>* frames;
};
class GetContextFrame: public StackwalkerAMD64Fixture, public Test { };
@@ -166,7 +166,7 @@
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
ASSERT_GE(1U, frames->size());
- StackFrameAMD64 *frame = static_cast<StackFrameAMD64 *>(frames->at(0));
+ StackFrameAMD64 *frame = static_cast<StackFrameAMD64*>(frames->at(0));
// Check that the values from the original raw context made it
// through to the context in the stack frame.
EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
@@ -192,7 +192,7 @@
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
ASSERT_GE(1U, frames->size());
- StackFrameAMD64 *frame = static_cast<StackFrameAMD64 *>(frames->at(0));
+ StackFrameAMD64 *frame = static_cast<StackFrameAMD64*>(frames->at(0));
// Check that the values from the original raw context made it
// through to the context in the stack frame.
EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
@@ -216,7 +216,7 @@
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
ASSERT_GE(1U, frames->size());
- StackFrameAMD64 *frame = static_cast<StackFrameAMD64 *>(frames->at(0));
+ StackFrameAMD64 *frame = static_cast<StackFrameAMD64*>(frames->at(0));
// Check that the values from the original raw context made it
// through to the context in the stack frame.
EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
@@ -279,12 +279,12 @@
frames = call_stack.frames();
ASSERT_EQ(3U, frames->size());
- StackFrameAMD64 *frame0 = static_cast<StackFrameAMD64 *>(frames->at(0));
+ StackFrameAMD64 *frame0 = static_cast<StackFrameAMD64*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameAMD64::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
- StackFrameAMD64 *frame1 = static_cast<StackFrameAMD64 *>(frames->at(1));
+ StackFrameAMD64 *frame1 = static_cast<StackFrameAMD64*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
ASSERT_EQ((StackFrameAMD64::CONTEXT_VALID_RIP |
StackFrameAMD64::CONTEXT_VALID_RSP |
@@ -294,7 +294,7 @@
EXPECT_EQ(frame1_sp.Value(), frame1->context.rsp);
EXPECT_EQ(frame1_rbp.Value(), frame1->context.rbp);
- StackFrameAMD64 *frame2 = static_cast<StackFrameAMD64 *>(frames->at(2));
+ StackFrameAMD64 *frame2 = static_cast<StackFrameAMD64*>(frames->at(2));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame2->trust);
ASSERT_EQ((StackFrameAMD64::CONTEXT_VALID_RIP |
StackFrameAMD64::CONTEXT_VALID_RSP),
@@ -352,13 +352,13 @@
frames = call_stack.frames();
ASSERT_EQ(2U, frames->size());
- StackFrameAMD64 *frame0 = static_cast<StackFrameAMD64 *>(frames->at(0));
+ StackFrameAMD64 *frame0 = static_cast<StackFrameAMD64*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameAMD64::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ("platypus", frame0->function_name);
EXPECT_EQ(0x00007400c0000100ULL, frame0->function_base);
- StackFrameAMD64 *frame1 = static_cast<StackFrameAMD64 *>(frames->at(1));
+ StackFrameAMD64 *frame1 = static_cast<StackFrameAMD64*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
ASSERT_EQ((StackFrameAMD64::CONTEXT_VALID_RIP |
StackFrameAMD64::CONTEXT_VALID_RSP |
@@ -464,7 +464,7 @@
ASSERT_EQ(3U, frames->size());
{ // To avoid reusing locals by mistake
- StackFrameAMD64 *frame = static_cast<StackFrameAMD64 *>(frames->at(0));
+ StackFrameAMD64 *frame = static_cast<StackFrameAMD64*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame->trust);
ASSERT_EQ(StackFrameAMD64::CONTEXT_VALID_ALL, frame->context_validity);
EXPECT_EQ("", frame->function_name);
@@ -475,7 +475,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameAMD64 *frame = static_cast<StackFrameAMD64 *>(frames->at(1));
+ StackFrameAMD64 *frame = static_cast<StackFrameAMD64*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame->trust);
ASSERT_EQ((StackFrameAMD64::CONTEXT_VALID_RIP |
StackFrameAMD64::CONTEXT_VALID_RSP |
@@ -489,7 +489,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameAMD64 *frame = static_cast<StackFrameAMD64 *>(frames->at(2));
+ StackFrameAMD64 *frame = static_cast<StackFrameAMD64*>(frames->at(2));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame->trust);
ASSERT_EQ((StackFrameAMD64::CONTEXT_VALID_RIP |
StackFrameAMD64::CONTEXT_VALID_RSP |
@@ -540,12 +540,12 @@
frames = call_stack.frames();
ASSERT_EQ(2U, frames->size());
- StackFrameAMD64 *frame0 = static_cast<StackFrameAMD64 *>(frames->at(0));
+ StackFrameAMD64 *frame0 = static_cast<StackFrameAMD64*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameAMD64::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
- StackFrameAMD64 *frame1 = static_cast<StackFrameAMD64 *>(frames->at(1));
+ StackFrameAMD64 *frame1 = static_cast<StackFrameAMD64*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
ASSERT_EQ((StackFrameAMD64::CONTEXT_VALID_RIP |
StackFrameAMD64::CONTEXT_VALID_RSP),
@@ -590,12 +590,12 @@
frames = call_stack.frames();
ASSERT_EQ(2U, frames->size());
- StackFrameAMD64 *frame0 = static_cast<StackFrameAMD64 *>(frames->at(0));
+ StackFrameAMD64 *frame0 = static_cast<StackFrameAMD64*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameAMD64::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
- StackFrameAMD64 *frame1 = static_cast<StackFrameAMD64 *>(frames->at(1));
+ StackFrameAMD64 *frame1 = static_cast<StackFrameAMD64*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
ASSERT_EQ((StackFrameAMD64::CONTEXT_VALID_RIP |
StackFrameAMD64::CONTEXT_VALID_RSP),
@@ -660,7 +660,7 @@
frames = call_stack.frames();
ASSERT_EQ(1U, frames->size());
- StackFrameAMD64 *frame0 = static_cast<StackFrameAMD64 *>(frames->at(0));
+ StackFrameAMD64 *frame0 = static_cast<StackFrameAMD64*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameAMD64::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
@@ -718,14 +718,14 @@
frames = call_stack.frames();
ASSERT_EQ(2U, frames->size());
- StackFrameAMD64 *frame0 = static_cast<StackFrameAMD64 *>(frames->at(0));
+ StackFrameAMD64 *frame0 = static_cast<StackFrameAMD64*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameAMD64::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(frame0_rbp.Value(), frame0->context.rbp);
EXPECT_EQ("sasquatch", frame0->function_name);
EXPECT_EQ(0x00007400c0000100ULL, frame0->function_base);
- StackFrameAMD64 *frame1 = static_cast<StackFrameAMD64 *>(frames->at(1));
+ StackFrameAMD64 *frame1 = static_cast<StackFrameAMD64*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_FP, frame1->trust);
ASSERT_EQ((StackFrameAMD64::CONTEXT_VALID_RIP |
StackFrameAMD64::CONTEXT_VALID_RSP |
@@ -799,13 +799,13 @@
frames = call_stack.frames();
ASSERT_EQ(2U, frames->size());
- StackFrameAMD64 *frame0 = static_cast<StackFrameAMD64 *>(frames->at(0));
+ StackFrameAMD64 *frame0 = static_cast<StackFrameAMD64*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameAMD64::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ("enchiridion", frame0->function_name);
EXPECT_EQ(0x00007400c0004000ULL, frame0->function_base);
- StackFrameAMD64 *frame1 = static_cast<StackFrameAMD64 *>(frames->at(1));
+ StackFrameAMD64 *frame1 = static_cast<StackFrameAMD64*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame1->trust);
ASSERT_EQ((StackFrameAMD64::CONTEXT_VALID_RIP |
StackFrameAMD64::CONTEXT_VALID_RSP |
diff --git a/src/processor/stackwalker_arm.cc b/src/processor/stackwalker_arm.cc
index 1313416..f6f2c9b 100644
--- a/src/processor/stackwalker_arm.cc
+++ b/src/processor/stackwalker_arm.cc
@@ -78,7 +78,7 @@
}
StackFrameARM* StackwalkerARM::GetCallerByCFIFrameInfo(
- const vector<StackFrame*> &frames,
+ const vector<StackFrame*>& frames,
CFIFrameInfo* cfi_frame_info) {
StackFrameARM* last_frame = static_cast<StackFrameARM*>(frames.back());
@@ -162,7 +162,7 @@
}
StackFrameARM* StackwalkerARM::GetCallerByStackScan(
- const vector<StackFrame*> &frames) {
+ const vector<StackFrame*>& frames) {
StackFrameARM* last_frame = static_cast<StackFrameARM*>(frames.back());
uint32_t last_sp = last_frame->context.iregs[MD_CONTEXT_ARM_REG_SP];
uint32_t caller_sp, caller_pc;
@@ -193,7 +193,7 @@
}
StackFrameARM* StackwalkerARM::GetCallerByFramePointer(
- const vector<StackFrame*> &frames) {
+ const vector<StackFrame*>& frames) {
StackFrameARM* last_frame = static_cast<StackFrameARM*>(frames.back());
if (!(last_frame->context_validity &
@@ -245,7 +245,7 @@
return NULL;
}
- const vector<StackFrame*> &frames = *stack->frames();
+ const vector<StackFrame*>& frames = *stack->frames();
StackFrameARM* last_frame = static_cast<StackFrameARM*>(frames.back());
scoped_ptr<StackFrameARM> frame;
diff --git a/src/processor/stackwalker_arm.h b/src/processor/stackwalker_arm.h
index 9081a40..72ddddc 100644
--- a/src/processor/stackwalker_arm.h
+++ b/src/processor/stackwalker_arm.h
@@ -75,16 +75,16 @@
// Use cfi_frame_info (derived from STACK CFI records) to construct
// the frame that called frames.back(). The caller takes ownership
// of the returned frame. Return NULL on failure.
- StackFrameARM* GetCallerByCFIFrameInfo(const vector<StackFrame*> &frames,
+ StackFrameARM* GetCallerByCFIFrameInfo(const vector<StackFrame*>& frames,
CFIFrameInfo* cfi_frame_info);
// Use the frame pointer. The caller takes ownership of the returned frame.
// Return NULL on failure.
- StackFrameARM* GetCallerByFramePointer(const vector<StackFrame*> &frames);
+ StackFrameARM* GetCallerByFramePointer(const vector<StackFrame*>& frames);
// Scan the stack for plausible return addresses. The caller takes ownership
// of the returned frame. Return NULL on failure.
- StackFrameARM* GetCallerByStackScan(const vector<StackFrame*> &frames);
+ StackFrameARM* GetCallerByStackScan(const vector<StackFrame*>& frames);
// Stores the CPU context corresponding to the youngest stack frame, to
// be returned by GetContextFrame.
diff --git a/src/processor/stackwalker_arm64.cc b/src/processor/stackwalker_arm64.cc
index 5bfd263..9acf818 100644
--- a/src/processor/stackwalker_arm64.cc
+++ b/src/processor/stackwalker_arm64.cc
@@ -99,7 +99,7 @@
}
StackFrameARM64* StackwalkerARM64::GetCallerByCFIFrameInfo(
- const vector<StackFrame*> &frames,
+ const vector<StackFrame*>& frames,
CFIFrameInfo* cfi_frame_info) {
StackFrameARM64* last_frame = static_cast<StackFrameARM64*>(frames.back());
@@ -175,7 +175,7 @@
}
StackFrameARM64* StackwalkerARM64::GetCallerByStackScan(
- const vector<StackFrame*> &frames) {
+ const vector<StackFrame*>& frames) {
StackFrameARM64* last_frame = static_cast<StackFrameARM64*>(frames.back());
uint64_t last_sp = last_frame->context.iregs[MD_CONTEXT_ARM64_REG_SP];
uint64_t caller_sp, caller_pc;
@@ -206,7 +206,7 @@
}
StackFrameARM64* StackwalkerARM64::GetCallerByFramePointer(
- const vector<StackFrame*> &frames) {
+ const vector<StackFrame*>& frames) {
StackFrameARM64* last_frame = static_cast<StackFrameARM64*>(frames.back());
if (!(last_frame->context_validity & StackFrameARM64::CONTEXT_VALID_LR)) {
CorrectRegLRByFramePointer(frames, last_frame);
@@ -294,7 +294,7 @@
return NULL;
}
- const vector<StackFrame*> &frames = *stack->frames();
+ const vector<StackFrame*>& frames = *stack->frames();
StackFrameARM64* last_frame = static_cast<StackFrameARM64*>(frames.back());
scoped_ptr<StackFrameARM64> frame;
diff --git a/src/processor/stackwalker_arm64.h b/src/processor/stackwalker_arm64.h
index 39735c6..4c7da3f 100644
--- a/src/processor/stackwalker_arm64.h
+++ b/src/processor/stackwalker_arm64.h
@@ -79,16 +79,16 @@
// Use cfi_frame_info (derived from STACK CFI records) to construct
// the frame that called frames.back(). The caller takes ownership
// of the returned frame. Return NULL on failure.
- StackFrameARM64* GetCallerByCFIFrameInfo(const vector<StackFrame*> &frames,
+ StackFrameARM64* GetCallerByCFIFrameInfo(const vector<StackFrame*>& frames,
CFIFrameInfo* cfi_frame_info);
// Use the frame pointer. The caller takes ownership of the returned frame.
// Return NULL on failure.
- StackFrameARM64* GetCallerByFramePointer(const vector<StackFrame*> &frames);
+ StackFrameARM64* GetCallerByFramePointer(const vector<StackFrame*>& frames);
// Scan the stack for plausible return addresses. The caller takes ownership
// of the returned frame. Return NULL on failure.
- StackFrameARM64* GetCallerByStackScan(const vector<StackFrame*> &frames);
+ StackFrameARM64* GetCallerByStackScan(const vector<StackFrame*>& frames);
// GetCallerByFramePointer() depends on the previous frame having recovered
// x30($LR) which may not have been done when using CFI.
diff --git a/src/processor/stackwalker_arm64_unittest.cc b/src/processor/stackwalker_arm64_unittest.cc
index d86fa12..6553e0c 100644
--- a/src/processor/stackwalker_arm64_unittest.cc
+++ b/src/processor/stackwalker_arm64_unittest.cc
@@ -105,7 +105,7 @@
// Set the Breakpad symbol information that supplier should return for
// MODULE to INFO.
- void SetModuleSymbols(MockCodeModule *module, const string &info) {
+ void SetModuleSymbols(MockCodeModule* module, const string& info) {
size_t buffer_size;
char *buffer = supplier.CopySymbolDataAndOwnTheCopy(info, &buffer_size);
EXPECT_CALL(supplier, GetCStringSymbolData(module, &system_info, _, _, _))
@@ -126,7 +126,7 @@
void BrandContext(MDRawContextARM64 *raw_context) {
uint8_t x = 173;
for (size_t i = 0; i < sizeof(*raw_context); i++)
- reinterpret_cast<uint8_t *>(raw_context)[i] = (x += 17);
+ reinterpret_cast<uint8_t*>(raw_context)[i] = (x += 17);
}
SystemInfo system_info;
@@ -139,7 +139,7 @@
MockSymbolSupplier supplier;
BasicSourceLineResolver resolver;
CallStack call_stack;
- const vector<StackFrame *> *frames;
+ const vector<StackFrame*>* frames;
};
class SanityCheck: public StackwalkerARM64Fixture, public Test { };
@@ -159,7 +159,7 @@
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
ASSERT_EQ(1U, frames->size());
- StackFrameARM64 *frame = static_cast<StackFrameARM64 *>(frames->at(0));
+ StackFrameARM64 *frame = static_cast<StackFrameARM64*>(frames->at(0));
// Check that the values from the original raw context made it
// through to the context in the stack frame.
EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
@@ -181,7 +181,7 @@
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
ASSERT_EQ(1U, frames->size());
- StackFrameARM64 *frame = static_cast<StackFrameARM64 *>(frames->at(0));
+ StackFrameARM64 *frame = static_cast<StackFrameARM64*>(frames->at(0));
// Check that the values from the original raw context made it
// through to the context in the stack frame.
EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
@@ -237,13 +237,13 @@
frames = call_stack.frames();
ASSERT_EQ(3U, frames->size());
- StackFrameARM64 *frame0 = static_cast<StackFrameARM64 *>(frames->at(0));
+ StackFrameARM64 *frame0 = static_cast<StackFrameARM64*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameARM64::CONTEXT_VALID_ALL,
frame0->context_validity);
EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
- StackFrameARM64 *frame1 = static_cast<StackFrameARM64 *>(frames->at(1));
+ StackFrameARM64 *frame1 = static_cast<StackFrameARM64*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
ASSERT_EQ((StackFrameARM64::CONTEXT_VALID_PC |
StackFrameARM64::CONTEXT_VALID_SP),
@@ -251,7 +251,7 @@
EXPECT_EQ(return_address1, frame1->context.iregs[MD_CONTEXT_ARM64_REG_PC]);
EXPECT_EQ(frame1_sp.Value(), frame1->context.iregs[MD_CONTEXT_ARM64_REG_SP]);
- StackFrameARM64 *frame2 = static_cast<StackFrameARM64 *>(frames->at(2));
+ StackFrameARM64 *frame2 = static_cast<StackFrameARM64*>(frames->at(2));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame2->trust);
ASSERT_EQ((StackFrameARM64::CONTEXT_VALID_PC |
StackFrameARM64::CONTEXT_VALID_SP),
@@ -307,7 +307,7 @@
frames = call_stack.frames();
ASSERT_EQ(2U, frames->size());
- StackFrameARM64 *frame0 = static_cast<StackFrameARM64 *>(frames->at(0));
+ StackFrameARM64 *frame0 = static_cast<StackFrameARM64*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameARM64::CONTEXT_VALID_ALL,
frame0->context_validity);
@@ -315,7 +315,7 @@
EXPECT_EQ("monotreme", frame0->function_name);
EXPECT_EQ(0x40000100ULL, frame0->function_base);
- StackFrameARM64 *frame1 = static_cast<StackFrameARM64 *>(frames->at(1));
+ StackFrameARM64 *frame1 = static_cast<StackFrameARM64*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
ASSERT_EQ((StackFrameARM64::CONTEXT_VALID_PC |
StackFrameARM64::CONTEXT_VALID_SP),
@@ -376,13 +376,13 @@
frames = call_stack.frames();
ASSERT_EQ(2U, frames->size());
- StackFrameARM64 *frame0 = static_cast<StackFrameARM64 *>(frames->at(0));
+ StackFrameARM64 *frame0 = static_cast<StackFrameARM64*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameARM64::CONTEXT_VALID_ALL,
frame0->context_validity);
EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
- StackFrameARM64 *frame1 = static_cast<StackFrameARM64 *>(frames->at(1));
+ StackFrameARM64 *frame1 = static_cast<StackFrameARM64*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
ASSERT_EQ((StackFrameARM64::CONTEXT_VALID_PC |
StackFrameARM64::CONTEXT_VALID_SP),
@@ -440,7 +440,7 @@
frames = call_stack.frames();
ASSERT_EQ(1U, frames->size());
- StackFrameARM64 *frame0 = static_cast<StackFrameARM64 *>(frames->at(0));
+ StackFrameARM64 *frame0 = static_cast<StackFrameARM64*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameARM64::CONTEXT_VALID_ALL,
frame0->context_validity);
@@ -503,13 +503,13 @@
frames = call_stack.frames();
ASSERT_EQ(3U, frames->size());
- StackFrameARM64 *frame0 = static_cast<StackFrameARM64 *>(frames->at(0));
+ StackFrameARM64 *frame0 = static_cast<StackFrameARM64*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameARM64::CONTEXT_VALID_ALL,
frame0->context_validity);
EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
- StackFrameARM64 *frame1 = static_cast<StackFrameARM64 *>(frames->at(1));
+ StackFrameARM64 *frame1 = static_cast<StackFrameARM64*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_FP, frame1->trust);
ASSERT_EQ((StackFrameARM64::CONTEXT_VALID_PC |
StackFrameARM64::CONTEXT_VALID_LR |
@@ -522,7 +522,7 @@
EXPECT_EQ(frame2_fp.Value(),
frame1->context.iregs[MD_CONTEXT_ARM64_REG_FP]);
- StackFrameARM64 *frame2 = static_cast<StackFrameARM64 *>(frames->at(2));
+ StackFrameARM64 *frame2 = static_cast<StackFrameARM64*>(frames->at(2));
EXPECT_EQ(StackFrame::FRAME_TRUST_FP, frame2->trust);
ASSERT_EQ((StackFrameARM64::CONTEXT_VALID_PC |
StackFrameARM64::CONTEXT_VALID_LR |
@@ -642,13 +642,13 @@
frames = call_stack.frames();
ASSERT_EQ(2U, frames->size());
- StackFrameARM64 *frame0 = static_cast<StackFrameARM64 *>(frames->at(0));
+ StackFrameARM64 *frame0 = static_cast<StackFrameARM64*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(context_frame_validity, frame0->context_validity);
EXPECT_EQ("enchiridion", frame0->function_name);
EXPECT_EQ(0x0000000040004000UL, frame0->function_base);
- StackFrameARM64 *frame1 = static_cast<StackFrameARM64 *>(frames->at(1));
+ StackFrameARM64 *frame1 = static_cast<StackFrameARM64*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame1->trust);
ASSERT_EQ(expected_validity, frame1->context_validity);
if (expected_validity & StackFrameARM64::CONTEXT_VALID_X1)
diff --git a/src/processor/stackwalker_arm_unittest.cc b/src/processor/stackwalker_arm_unittest.cc
index 256f764..046081f 100644
--- a/src/processor/stackwalker_arm_unittest.cc
+++ b/src/processor/stackwalker_arm_unittest.cc
@@ -106,7 +106,7 @@
// Set the Breakpad symbol information that supplier should return for
// MODULE to INFO.
- void SetModuleSymbols(MockCodeModule *module, const string &info) {
+ void SetModuleSymbols(MockCodeModule* module, const string& info) {
size_t buffer_size;
char *buffer = supplier.CopySymbolDataAndOwnTheCopy(info, &buffer_size);
EXPECT_CALL(supplier, GetCStringSymbolData(module, &system_info, _, _, _))
@@ -127,7 +127,7 @@
void BrandContext(MDRawContextARM *raw_context) {
uint8_t x = 173;
for (size_t i = 0; i < sizeof(*raw_context); i++)
- reinterpret_cast<uint8_t *>(raw_context)[i] = (x += 17);
+ reinterpret_cast<uint8_t*>(raw_context)[i] = (x += 17);
}
SystemInfo system_info;
@@ -140,7 +140,7 @@
MockSymbolSupplier supplier;
BasicSourceLineResolver resolver;
CallStack call_stack;
- const vector<StackFrame *> *frames;
+ const vector<StackFrame*>* frames;
};
class SanityCheck: public StackwalkerARMFixture, public Test { };
@@ -161,7 +161,7 @@
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
ASSERT_EQ(1U, frames->size());
- StackFrameARM *frame = static_cast<StackFrameARM *>(frames->at(0));
+ StackFrameARM *frame = static_cast<StackFrameARM*>(frames->at(0));
// Check that the values from the original raw context made it
// through to the context in the stack frame.
EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
@@ -184,7 +184,7 @@
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
ASSERT_EQ(1U, frames->size());
- StackFrameARM *frame = static_cast<StackFrameARM *>(frames->at(0));
+ StackFrameARM *frame = static_cast<StackFrameARM*>(frames->at(0));
// Check that the values from the original raw context made it
// through to the context in the stack frame.
EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
@@ -204,7 +204,7 @@
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
ASSERT_EQ(1U, frames->size());
- StackFrameARM *frame = static_cast<StackFrameARM *>(frames->at(0));
+ StackFrameARM *frame = static_cast<StackFrameARM*>(frames->at(0));
// Check that the values from the original raw context made it
// through to the context in the stack frame.
EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
@@ -260,12 +260,12 @@
frames = call_stack.frames();
ASSERT_EQ(3U, frames->size());
- StackFrameARM *frame0 = static_cast<StackFrameARM *>(frames->at(0));
+ StackFrameARM *frame0 = static_cast<StackFrameARM*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameARM::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
- StackFrameARM *frame1 = static_cast<StackFrameARM *>(frames->at(1));
+ StackFrameARM *frame1 = static_cast<StackFrameARM*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
ASSERT_EQ((StackFrameARM::CONTEXT_VALID_PC |
StackFrameARM::CONTEXT_VALID_SP),
@@ -273,7 +273,7 @@
EXPECT_EQ(return_address1, frame1->context.iregs[MD_CONTEXT_ARM_REG_PC]);
EXPECT_EQ(frame1_sp.Value(), frame1->context.iregs[MD_CONTEXT_ARM_REG_SP]);
- StackFrameARM *frame2 = static_cast<StackFrameARM *>(frames->at(2));
+ StackFrameARM *frame2 = static_cast<StackFrameARM*>(frames->at(2));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame2->trust);
ASSERT_EQ((StackFrameARM::CONTEXT_VALID_PC |
StackFrameARM::CONTEXT_VALID_SP),
@@ -329,14 +329,14 @@
frames = call_stack.frames();
ASSERT_EQ(2U, frames->size());
- StackFrameARM *frame0 = static_cast<StackFrameARM *>(frames->at(0));
+ StackFrameARM *frame0 = static_cast<StackFrameARM*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameARM::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
EXPECT_EQ("monotreme", frame0->function_name);
EXPECT_EQ(0x40000100U, frame0->function_base);
- StackFrameARM *frame1 = static_cast<StackFrameARM *>(frames->at(1));
+ StackFrameARM *frame1 = static_cast<StackFrameARM*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
ASSERT_EQ((StackFrameARM::CONTEXT_VALID_PC |
StackFrameARM::CONTEXT_VALID_SP),
@@ -397,12 +397,12 @@
frames = call_stack.frames();
ASSERT_EQ(2U, frames->size());
- StackFrameARM *frame0 = static_cast<StackFrameARM *>(frames->at(0));
+ StackFrameARM *frame0 = static_cast<StackFrameARM*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameARM::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
- StackFrameARM *frame1 = static_cast<StackFrameARM *>(frames->at(1));
+ StackFrameARM *frame1 = static_cast<StackFrameARM*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
ASSERT_EQ((StackFrameARM::CONTEXT_VALID_PC |
StackFrameARM::CONTEXT_VALID_SP),
@@ -460,7 +460,7 @@
frames = call_stack.frames();
ASSERT_EQ(1U, frames->size());
- StackFrameARM *frame0 = static_cast<StackFrameARM *>(frames->at(0));
+ StackFrameARM *frame0 = static_cast<StackFrameARM*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameARM::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
@@ -565,13 +565,13 @@
frames = call_stack.frames();
ASSERT_EQ(2U, frames->size());
- StackFrameARM *frame0 = static_cast<StackFrameARM *>(frames->at(0));
+ StackFrameARM *frame0 = static_cast<StackFrameARM*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(context_frame_validity, frame0->context_validity);
EXPECT_EQ("enchiridion", frame0->function_name);
EXPECT_EQ(0x40004000U, frame0->function_base);
- StackFrameARM *frame1 = static_cast<StackFrameARM *>(frames->at(1));
+ StackFrameARM *frame1 = static_cast<StackFrameARM*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame1->trust);
ASSERT_EQ(expected_validity, frame1->context_validity);
if (expected_validity & StackFrameARM::CONTEXT_VALID_R1)
@@ -848,12 +848,12 @@
frames = call_stack.frames();
ASSERT_EQ(3U, frames->size());
- StackFrameARM *frame0 = static_cast<StackFrameARM *>(frames->at(0));
+ StackFrameARM *frame0 = static_cast<StackFrameARM*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameARM::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
- StackFrameARM *frame1 = static_cast<StackFrameARM *>(frames->at(1));
+ StackFrameARM *frame1 = static_cast<StackFrameARM*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_FP, frame1->trust);
ASSERT_EQ((StackFrameARM::CONTEXT_VALID_PC |
StackFrameARM::CONTEXT_VALID_LR |
@@ -866,7 +866,7 @@
EXPECT_EQ(frame2_fp.Value(),
frame1->context.iregs[MD_CONTEXT_ARM_REG_IOS_FP]);
- StackFrameARM *frame2 = static_cast<StackFrameARM *>(frames->at(2));
+ StackFrameARM *frame2 = static_cast<StackFrameARM*>(frames->at(2));
EXPECT_EQ(StackFrame::FRAME_TRUST_FP, frame2->trust);
ASSERT_EQ((StackFrameARM::CONTEXT_VALID_PC |
StackFrameARM::CONTEXT_VALID_LR |
@@ -944,12 +944,12 @@
frames = call_stack.frames();
ASSERT_EQ(3U, frames->size());
- StackFrameARM *frame0 = static_cast<StackFrameARM *>(frames->at(0));
+ StackFrameARM *frame0 = static_cast<StackFrameARM*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameARM::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
- StackFrameARM *frame1 = static_cast<StackFrameARM *>(frames->at(1));
+ StackFrameARM *frame1 = static_cast<StackFrameARM*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_FP, frame1->trust);
ASSERT_EQ((StackFrameARM::CONTEXT_VALID_PC |
StackFrameARM::CONTEXT_VALID_LR |
@@ -965,7 +965,7 @@
EXPECT_EQ(0x40004000U, frame1->function_base);
- StackFrameARM *frame2 = static_cast<StackFrameARM *>(frames->at(2));
+ StackFrameARM *frame2 = static_cast<StackFrameARM*>(frames->at(2));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame2->trust);
ASSERT_EQ((StackFrameARM::CONTEXT_VALID_PC |
StackFrameARM::CONTEXT_VALID_LR |
diff --git a/src/processor/stackwalker_selftest.cc b/src/processor/stackwalker_selftest.cc
index f692d4c..dcb2df0 100644
--- a/src/processor/stackwalker_selftest.cc
+++ b/src/processor/stackwalker_selftest.cc
@@ -420,7 +420,7 @@
// Not i386 or ppc or sparc? We can only test stacks we know how to walk.
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
BPLOG_INIT(&argc, &argv);
// "make check" interprets an exit status of 77 to mean that the test is
diff --git a/src/processor/stackwalker_unittest_utils.h b/src/processor/stackwalker_unittest_utils.h
index 3a92a5e..2905ea0 100644
--- a/src/processor/stackwalker_unittest_utils.h
+++ b/src/processor/stackwalker_unittest_utils.h
@@ -57,7 +57,7 @@
// Set this region's address and contents. If we have placed an
// instance of this class in a test fixture class, individual tests
// can use this to provide the region's contents.
- void Init(uint64_t base_address, const string &contents) {
+ void Init(uint64_t base_address, const string& contents) {
base_address_ = base_address;
contents_ = contents;
}
@@ -65,16 +65,16 @@
uint64_t GetBase() const { return base_address_; }
uint32_t GetSize() const { return contents_.size(); }
- bool GetMemoryAtAddress(uint64_t address, uint8_t *value) const {
+ bool GetMemoryAtAddress(uint64_t address, uint8_t* value) const {
return GetMemoryLittleEndian(address, value);
}
- bool GetMemoryAtAddress(uint64_t address, uint16_t *value) const {
+ bool GetMemoryAtAddress(uint64_t address, uint16_t* value) const {
return GetMemoryLittleEndian(address, value);
}
- bool GetMemoryAtAddress(uint64_t address, uint32_t *value) const {
+ bool GetMemoryAtAddress(uint64_t address, uint32_t* value) const {
return GetMemoryLittleEndian(address, value);
}
- bool GetMemoryAtAddress(uint64_t address, uint64_t *value) const {
+ bool GetMemoryAtAddress(uint64_t address, uint64_t* value) const {
return GetMemoryLittleEndian(address, value);
}
void Print() const {
@@ -85,7 +85,7 @@
// Fetch a little-endian value from ADDRESS in contents_ whose size
// is BYTES, and store it in *VALUE. Return true on success.
template<typename ValueType>
- bool GetMemoryLittleEndian(uint64_t address, ValueType *value) const {
+ bool GetMemoryLittleEndian(uint64_t address, ValueType* value) const {
if (address < base_address_ ||
address - base_address_ + sizeof(ValueType) > contents_.size())
return false;
@@ -105,7 +105,7 @@
class MockCodeModule: public google_breakpad::CodeModule {
public:
MockCodeModule(uint64_t base_address, uint64_t size,
- const string &code_file, const string &version)
+ const string& code_file, const string& version)
: base_address_(base_address), size_(size), code_file_(code_file) { }
uint64_t base_address() const { return base_address_; }
@@ -115,7 +115,7 @@
string debug_file() const { return code_file_; }
string debug_identifier() const { return code_file_; }
string version() const { return version_; }
- google_breakpad::CodeModule *Copy() const {
+ google_breakpad::CodeModule* Copy() const {
abort(); // Tests won't use this.
}
virtual bool is_unloaded() const { return false; }
@@ -134,16 +134,16 @@
typedef google_breakpad::CodeModule CodeModule;
typedef google_breakpad::CodeModules CodeModules;
- void Add(const MockCodeModule *module) {
+ void Add(const MockCodeModule* module) {
modules_.push_back(module);
}
unsigned int module_count() const { return modules_.size(); }
- const CodeModule *GetModuleForAddress(uint64_t address) const {
+ const CodeModule* GetModuleForAddress(uint64_t address) const {
for (ModuleVector::const_iterator i = modules_.begin();
i != modules_.end(); i++) {
- const MockCodeModule *module = *i;
+ const MockCodeModule* module = *i;
if (module->base_address() <= address &&
address - module->base_address() < module->size())
return module;
@@ -151,17 +151,17 @@
return NULL;
};
- const CodeModule *GetMainModule() const { return modules_[0]; }
+ const CodeModule* GetMainModule() const { return modules_[0]; }
- const CodeModule *GetModuleAtSequence(unsigned int sequence) const {
+ const CodeModule* GetModuleAtSequence(unsigned int sequence) const {
return modules_.at(sequence);
}
- const CodeModule *GetModuleAtIndex(unsigned int index) const {
+ const CodeModule* GetModuleAtIndex(unsigned int index) const {
return modules_.at(index);
}
- CodeModules *Copy() const { abort(); } // Tests won't use this
+ CodeModules* Copy() const { abort(); } // Tests won't use this
virtual std::vector<google_breakpad::linked_ptr<const CodeModule> >
GetShrunkRangeModules() const {
@@ -169,7 +169,7 @@
}
private:
- typedef std::vector<const MockCodeModule *> ModuleVector;
+ typedef std::vector<const MockCodeModule*> ModuleVector;
ModuleVector modules_;
};
@@ -177,26 +177,26 @@
public:
typedef google_breakpad::CodeModule CodeModule;
typedef google_breakpad::SystemInfo SystemInfo;
- MOCK_METHOD3(GetSymbolFile, SymbolResult(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file));
- MOCK_METHOD4(GetSymbolFile, SymbolResult(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file,
- string *symbol_data));
- MOCK_METHOD5(GetCStringSymbolData, SymbolResult(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file,
- char **symbol_data,
- size_t *symbol_data_size));
- MOCK_METHOD1(FreeSymbolData, void(const CodeModule *module));
+ MOCK_METHOD3(GetSymbolFile, SymbolResult(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file));
+ MOCK_METHOD4(GetSymbolFile, SymbolResult(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file,
+ string* symbol_data));
+ MOCK_METHOD5(GetCStringSymbolData, SymbolResult(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file,
+ char** symbol_data,
+ size_t* symbol_data_size));
+ MOCK_METHOD1(FreeSymbolData, void(const CodeModule* module));
// Copies the passed string contents into a newly allocated buffer.
// The newly allocated buffer will be freed during destruction.
- char* CopySymbolDataAndOwnTheCopy(const string &info,
- size_t *symbol_data_size) {
+ char* CopySymbolDataAndOwnTheCopy(const string& info,
+ size_t* symbol_data_size) {
*symbol_data_size = info.size() + 1;
- char *symbol_data = new char[*symbol_data_size];
+ char* symbol_data = new char[*symbol_data_size];
memcpy(symbol_data, info.c_str(), info.size());
symbol_data[info.size()] = '\0';
symbol_data_to_free_.push_back(symbol_data);
diff --git a/src/processor/stackwalker_x86.cc b/src/processor/stackwalker_x86.cc
index ed2b383..b11e061 100644
--- a/src/processor/stackwalker_x86.cc
+++ b/src/processor/stackwalker_x86.cc
@@ -136,7 +136,7 @@
}
StackFrameX86* StackwalkerX86::GetCallerByWindowsFrameInfo(
- const vector<StackFrame*> &frames,
+ const vector<StackFrame*>& frames,
WindowsFrameInfo* last_frame_info,
bool stack_scan_allowed) {
StackFrame::FrameTrust trust = StackFrame::FRAME_TRUST_NONE;
@@ -514,7 +514,7 @@
}
StackFrameX86* StackwalkerX86::GetCallerByCFIFrameInfo(
- const vector<StackFrame*> &frames,
+ const vector<StackFrame*>& frames,
CFIFrameInfo* cfi_frame_info) {
StackFrameX86* last_frame = static_cast<StackFrameX86*>(frames.back());
last_frame->cfi_frame_info = cfi_frame_info;
@@ -539,7 +539,7 @@
}
StackFrameX86* StackwalkerX86::GetCallerByEBPAtBase(
- const vector<StackFrame*> &frames,
+ const vector<StackFrame*>& frames,
bool stack_scan_allowed) {
StackFrame::FrameTrust trust;
StackFrameX86* last_frame = static_cast<StackFrameX86*>(frames.back());
@@ -632,7 +632,7 @@
return NULL;
}
- const vector<StackFrame*> &frames = *stack->frames();
+ const vector<StackFrame*>& frames = *stack->frames();
StackFrameX86* last_frame = static_cast<StackFrameX86*>(frames.back());
scoped_ptr<StackFrameX86> new_frame;
diff --git a/src/processor/stackwalker_x86.h b/src/processor/stackwalker_x86.h
index 0659a13..1783fda 100644
--- a/src/processor/stackwalker_x86.h
+++ b/src/processor/stackwalker_x86.h
@@ -81,14 +81,14 @@
// to construct the frame that called frames.back(). The caller
// takes ownership of the returned frame. Return NULL on failure.
StackFrameX86* GetCallerByWindowsFrameInfo(
- const vector<StackFrame*> &frames,
+ const vector<StackFrame*>& frames,
WindowsFrameInfo* windows_frame_info,
bool stack_scan_allowed);
// Use cfi_frame_info (derived from STACK CFI records) to construct
// the frame that called frames.back(). The caller takes ownership
// of the returned frame. Return NULL on failure.
- StackFrameX86* GetCallerByCFIFrameInfo(const vector<StackFrame*> &frames,
+ StackFrameX86* GetCallerByCFIFrameInfo(const vector<StackFrame*>& frames,
CFIFrameInfo* cfi_frame_info);
// Assuming a traditional frame layout --- where the caller's %ebp
@@ -96,7 +96,7 @@
// %ebp points to the saved %ebp --- construct the frame that called
// frames.back(). The caller takes ownership of the returned frame.
// Return NULL on failure.
- StackFrameX86* GetCallerByEBPAtBase(const vector<StackFrame*> &frames,
+ StackFrameX86* GetCallerByEBPAtBase(const vector<StackFrame*>& frames,
bool stack_scan_allowed);
// Stores the CPU context corresponding to the innermost stack frame to
diff --git a/src/processor/stackwalker_x86_unittest.cc b/src/processor/stackwalker_x86_unittest.cc
index 359f1c8..b6f14a1 100644
--- a/src/processor/stackwalker_x86_unittest.cc
+++ b/src/processor/stackwalker_x86_unittest.cc
@@ -113,7 +113,7 @@
// Set the Breakpad symbol information that supplier should return for
// MODULE to INFO.
- void SetModuleSymbols(MockCodeModule *module, const string &info) {
+ void SetModuleSymbols(MockCodeModule* module, const string& info) {
size_t buffer_size;
char *buffer = supplier.CopySymbolDataAndOwnTheCopy(info, &buffer_size);
EXPECT_CALL(supplier, GetCStringSymbolData(module, &system_info, _, _, _))
@@ -134,7 +134,7 @@
void BrandContext(MDRawContextX86 *raw_context) {
uint8_t x = 173;
for (size_t i = 0; i < sizeof(*raw_context); i++)
- reinterpret_cast<uint8_t *>(raw_context)[i] = (x += 17);
+ reinterpret_cast<uint8_t*>(raw_context)[i] = (x += 17);
}
SystemInfo system_info;
@@ -151,7 +151,7 @@
MockSymbolSupplier supplier;
BasicSourceLineResolver resolver;
CallStack call_stack;
- const vector<StackFrame *> *frames;
+ const vector<StackFrame*>* frames;
};
class SanityCheck: public StackwalkerX86Fixture, public Test { };
@@ -175,7 +175,7 @@
ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
- StackFrameX86 *frame = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame = static_cast<StackFrameX86*>(frames->at(0));
// Check that the values from the original raw context made it
// through to the context in the stack frame.
EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
@@ -201,7 +201,7 @@
ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
- StackFrameX86 *frame = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame = static_cast<StackFrameX86*>(frames->at(0));
// Check that the values from the original raw context made it
// through to the context in the stack frame.
EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
@@ -224,7 +224,7 @@
ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
frames = call_stack.frames();
- StackFrameX86 *frame = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame = static_cast<StackFrameX86*>(frames->at(0));
// Check that the values from the original raw context made it
// through to the context in the stack frame.
EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
@@ -269,7 +269,7 @@
ASSERT_EQ(2U, frames->size());
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame0 = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame0 = static_cast<StackFrameX86*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
EXPECT_EQ(StackFrameX86::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0x4000c7a5U, frame0->instruction);
@@ -279,7 +279,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame1 = static_cast<StackFrameX86 *>(frames->at(1));
+ StackFrameX86 *frame1 = static_cast<StackFrameX86*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_FP, frame1->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP
| StackFrameX86::CONTEXT_VALID_ESP
@@ -333,7 +333,7 @@
ASSERT_EQ(2U, frames->size());
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame0 = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame0 = static_cast<StackFrameX86*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameX86::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0x4000f49dU, frame0->instruction);
@@ -344,7 +344,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame1 = static_cast<StackFrameX86 *>(frames->at(1));
+ StackFrameX86 *frame1 = static_cast<StackFrameX86*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP
| StackFrameX86::CONTEXT_VALID_ESP
@@ -399,7 +399,7 @@
ASSERT_EQ(2U, frames->size());
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame0 = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame0 = static_cast<StackFrameX86*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameX86::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0x4000f49dU, frame0->instruction);
@@ -410,7 +410,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame1 = static_cast<StackFrameX86 *>(frames->at(1));
+ StackFrameX86 *frame1 = static_cast<StackFrameX86*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP
| StackFrameX86::CONTEXT_VALID_ESP
@@ -465,7 +465,7 @@
ASSERT_EQ(1U, frames->size());
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame0 = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame0 = static_cast<StackFrameX86*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameX86::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0x4000f49dU, frame0->instruction);
@@ -524,7 +524,7 @@
ASSERT_EQ(2U, frames->size());
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame0 = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame0 = static_cast<StackFrameX86*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameX86::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0x4000aa85U, frame0->instruction);
@@ -535,7 +535,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame1 = static_cast<StackFrameX86 *>(frames->at(1));
+ StackFrameX86 *frame1 = static_cast<StackFrameX86*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame1->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP
| StackFrameX86::CONTEXT_VALID_ESP
@@ -605,7 +605,7 @@
ASSERT_EQ(2U, frames->size());
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame0 = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame0 = static_cast<StackFrameX86*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameX86::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0x4000aa85U, frame0->instruction);
@@ -616,7 +616,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame1 = static_cast<StackFrameX86 *>(frames->at(1));
+ StackFrameX86 *frame1 = static_cast<StackFrameX86*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame1->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP
| StackFrameX86::CONTEXT_VALID_ESP
@@ -693,7 +693,7 @@
ASSERT_EQ(3U, frames->size());
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame0 = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame0 = static_cast<StackFrameX86*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameX86::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0x40001004U, frame0->instruction);
@@ -714,7 +714,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame1 = static_cast<StackFrameX86 *>(frames->at(1));
+ StackFrameX86 *frame1 = static_cast<StackFrameX86*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_FP, frame1->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP
| StackFrameX86::CONTEXT_VALID_ESP
@@ -737,7 +737,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame2 = static_cast<StackFrameX86 *>(frames->at(2));
+ StackFrameX86 *frame2 = static_cast<StackFrameX86*>(frames->at(2));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame2->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP
| StackFrameX86::CONTEXT_VALID_ESP
@@ -793,7 +793,7 @@
ASSERT_EQ(2U, frames->size());
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame0 = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame0 = static_cast<StackFrameX86*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameX86::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0x40000c9cU, frame0->instruction);
@@ -804,7 +804,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame1 = static_cast<StackFrameX86 *>(frames->at(1));
+ StackFrameX86 *frame1 = static_cast<StackFrameX86*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
// I'd argue that CONTEXT_VALID_EBP shouldn't be here, since the walker
// does not actually fetch the EBP after a scan (forcing the next frame
@@ -882,7 +882,7 @@
ASSERT_EQ(2U, frames->size());
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame0 = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame0 = static_cast<StackFrameX86*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameX86::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0x40000700U, frame0->instruction);
@@ -893,7 +893,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame1 = static_cast<StackFrameX86 *>(frames->at(1));
+ StackFrameX86 *frame1 = static_cast<StackFrameX86*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI_SCAN, frame1->trust);
// I'd argue that CONTEXT_VALID_EBP shouldn't be here, since the
// walker does not actually fetch the EBP after a scan (forcing the
@@ -955,7 +955,7 @@
ASSERT_EQ(2U, frames->size());
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame0 = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame0 = static_cast<StackFrameX86*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameX86::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0x4000e8b8U, frame0->instruction);
@@ -976,7 +976,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame1 = static_cast<StackFrameX86 *>(frames->at(1));
+ StackFrameX86 *frame1 = static_cast<StackFrameX86*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame1->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP
| StackFrameX86::CONTEXT_VALID_ESP
@@ -1039,7 +1039,7 @@
ASSERT_EQ(2U, frames->size());
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame0 = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame0 = static_cast<StackFrameX86*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameX86::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0x40009ab8U, frame0->instruction);
@@ -1060,7 +1060,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame1 = static_cast<StackFrameX86 *>(frames->at(1));
+ StackFrameX86 *frame1 = static_cast<StackFrameX86*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame1->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP
| StackFrameX86::CONTEXT_VALID_ESP
@@ -1170,8 +1170,8 @@
StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
StackwalkerX86 walker(&system_info, &raw_context, &stack_region, &modules,
&frame_symbolizer);
- vector<const CodeModule *> modules_without_symbols;
- vector<const CodeModule *> modules_with_corrupt_symbols;
+ vector<const CodeModule*> modules_without_symbols;
+ vector<const CodeModule*> modules_with_corrupt_symbols;
ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
&modules_with_corrupt_symbols));
ASSERT_EQ(0U, modules_without_symbols.size());
@@ -1180,31 +1180,31 @@
ASSERT_EQ(5U, frames->size());
{
- const StackFrameX86 &frame = *static_cast<StackFrameX86 *>(frames->at(0));
+ const StackFrameX86& frame = *static_cast<StackFrameX86*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame.trust);
EXPECT_EQ(0x77726bf4U, frame.context.eip);
EXPECT_EQ("KiFastSystemCallRet", frame.function_name);
}
{
- const StackFrameX86 &frame = *static_cast<StackFrameX86 *>(frames->at(1));
+ const StackFrameX86& frame = *static_cast<StackFrameX86*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame.trust);
EXPECT_EQ(0x7772655cU, frame.context.eip);
EXPECT_EQ("NtWaitForKeyedEvent", frame.function_name);
}
{
- const StackFrameX86 &frame = *static_cast<StackFrameX86 *>(frames->at(2));
+ const StackFrameX86& frame = *static_cast<StackFrameX86*>(frames->at(2));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame.trust);
EXPECT_EQ(0x776e4a3fU, frame.context.eip);
EXPECT_EQ("RtlSleepConditionVariableSRW", frame.function_name);
}
{
- const StackFrameX86 &frame = *static_cast<StackFrameX86 *>(frames->at(3));
+ const StackFrameX86& frame = *static_cast<StackFrameX86*>(frames->at(3));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame.trust);
EXPECT_EQ(0x7728219eU, frame.context.eip);
EXPECT_EQ("SleepConditionVariableSRW", frame.function_name);
}
{
- const StackFrameX86 &frame = *static_cast<StackFrameX86 *>(frames->at(4));
+ const StackFrameX86& frame = *static_cast<StackFrameX86*>(frames->at(4));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame.trust);
EXPECT_EQ(0x5ac0486cU, frame.context.eip);
EXPECT_EQ("base::ConditionVariable::TimedWait", frame.function_name);
@@ -1318,7 +1318,7 @@
ASSERT_EQ(4U, frames->size());
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame0 = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame0 = static_cast<StackFrameX86*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameX86::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0x771ef8c1U, frame0->instruction);
@@ -1338,7 +1338,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame1 = static_cast<StackFrameX86 *>(frames->at(1));
+ StackFrameX86 *frame1 = static_cast<StackFrameX86*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame1->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP
| StackFrameX86::CONTEXT_VALID_ESP
@@ -1532,7 +1532,7 @@
ASSERT_EQ(3U, frames->size());
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame0 = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame0 = static_cast<StackFrameX86*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameX86::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(0x77c181cdU, frame0->instruction);
@@ -1554,7 +1554,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame1 = static_cast<StackFrameX86 *>(frames->at(1));
+ StackFrameX86 *frame1 = static_cast<StackFrameX86*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI_SCAN, frame1->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP |
StackFrameX86::CONTEXT_VALID_ESP |
@@ -1578,7 +1578,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame2 = static_cast<StackFrameX86 *>(frames->at(2));
+ StackFrameX86 *frame2 = static_cast<StackFrameX86*>(frames->at(2));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame2->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP |
StackFrameX86::CONTEXT_VALID_ESP |
@@ -1610,7 +1610,7 @@
MockCodeModule chrome_dll(0x59630000, 0x19e3000, "chrome.dll", "version1");
SetModuleSymbols(&chrome_dll, // chrome.dll
"FUNC 56422 50c 8 base::MessageLoop::RunTask"
- "(base::PendingTask const &)\n"
+ "(base::PendingTask const&)\n"
"56422 e 458 4589\n"
"STACK WIN 4 56422 50c 11 0 8 c ac 0 1 $T1 .raSearch = $T0 "
"$T1 4 - 8 @ = $ebp $T1 4 - ^ = $eip $T1 ^ = $esp $T1 4 + = "
@@ -1627,7 +1627,7 @@
"$T1 4 - 64 @ = $ebp $T1 4 - ^ = $eip $T1 ^ = $esp $T1 4 + "
"= $20 $T0 56 - ^ = $23 $T0 60 - ^ = $24 $T0 64 - ^ =\n"
"FUNC 55bf0 49 4 base::MessagePumpWin::Run(base::"
- "MessagePump::Delegate *)\n"
+ "MessagePump::Delegate*)\n"
"55bf0 49 48 4724\n"
"STACK WIN 4 55bf0 49 c 0 4 0 10 0 1 $T0 $ebp = $eip $T0 4 "
"+ ^ = $ebp $T0 ^ = $esp $T0 8 + =\n"
@@ -1735,7 +1735,7 @@
ASSERT_EQ(3U, frames->size());
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame = static_cast<StackFrameX86*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame->trust);
ASSERT_EQ(StackFrameX86::CONTEXT_VALID_ALL, frame->context_validity);
EXPECT_EQ("base::MessagePumpForIO::DoRunLoop()", frame->function_name);
@@ -1756,13 +1756,13 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame = static_cast<StackFrameX86 *>(frames->at(1));
+ StackFrameX86 *frame = static_cast<StackFrameX86*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP |
StackFrameX86::CONTEXT_VALID_ESP |
StackFrameX86::CONTEXT_VALID_EBP),
frame->context_validity);
- EXPECT_EQ("base::MessagePumpWin::Run(base::MessagePump::Delegate *)",
+ EXPECT_EQ("base::MessagePumpWin::Run(base::MessagePump::Delegate*)",
frame->function_name);
EXPECT_EQ(1500011566U, frame->instruction + 1);
EXPECT_EQ(1500011566U, frame->context.eip);
@@ -1779,7 +1779,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame = static_cast<StackFrameX86 *>(frames->at(2));
+ StackFrameX86 *frame = static_cast<StackFrameX86*>(frames->at(2));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP |
StackFrameX86::CONTEXT_VALID_ESP |
@@ -1984,7 +1984,7 @@
ASSERT_EQ(4U, frames->size());
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame0 = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame0 = static_cast<StackFrameX86*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameX86::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ(raw_context.eip, frame0->context.eip);
@@ -1996,7 +1996,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame1 = static_cast<StackFrameX86 *>(frames->at(1));
+ StackFrameX86 *frame1 = static_cast<StackFrameX86*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP |
StackFrameX86::CONTEXT_VALID_ESP |
@@ -2016,7 +2016,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame2 = static_cast<StackFrameX86 *>(frames->at(2));
+ StackFrameX86 *frame2 = static_cast<StackFrameX86*>(frames->at(2));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame2->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP |
StackFrameX86::CONTEXT_VALID_ESP |
@@ -2036,7 +2036,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame3 = static_cast<StackFrameX86 *>(frames->at(3));
+ StackFrameX86 *frame3 = static_cast<StackFrameX86*>(frames->at(3));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame3->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP |
StackFrameX86::CONTEXT_VALID_ESP |
@@ -2126,7 +2126,7 @@
ASSERT_EQ(2U, frames->size());
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame0 = static_cast<StackFrameX86 *>(frames->at(0));
+ StackFrameX86 *frame0 = static_cast<StackFrameX86*>(frames->at(0));
EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
ASSERT_EQ(StackFrameX86::CONTEXT_VALID_ALL, frame0->context_validity);
EXPECT_EQ("enchiridion", frame0->function_name);
@@ -2138,7 +2138,7 @@
}
{ // To avoid reusing locals by mistake
- StackFrameX86 *frame1 = static_cast<StackFrameX86 *>(frames->at(1));
+ StackFrameX86 *frame1 = static_cast<StackFrameX86*>(frames->at(1));
EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame1->trust);
ASSERT_EQ((StackFrameX86::CONTEXT_VALID_EIP |
StackFrameX86::CONTEXT_VALID_ESP |
diff --git a/src/processor/static_address_map-inl.h b/src/processor/static_address_map-inl.h
index 67e0797..9d2c1de 100644
--- a/src/processor/static_address_map-inl.h
+++ b/src/processor/static_address_map-inl.h
@@ -44,8 +44,8 @@
template<typename AddressType, typename EntryType>
bool StaticAddressMap<AddressType, EntryType>::Retrieve(
- const AddressType &address,
- const EntryType *&entry, AddressType *entry_address) const {
+ const AddressType& address,
+ const EntryType*& entry, AddressType* entry_address) const {
// upper_bound gives the first element whose key is greater than address,
// but we want the first element whose key is less than or equal to address.
diff --git a/src/processor/static_address_map.h b/src/processor/static_address_map.h
index 6bafc66..9d1a467 100644
--- a/src/processor/static_address_map.h
+++ b/src/processor/static_address_map.h
@@ -52,15 +52,15 @@
class StaticAddressMap {
public:
StaticAddressMap(): map_() { }
- explicit StaticAddressMap(const char *map_data): map_(map_data) { }
+ explicit StaticAddressMap(const char* map_data): map_(map_data) { }
// Locates the entry stored at the highest address less than or equal to
// the address argument. If there is no such range, returns false. The
// entry is returned in entry, which is a required argument. If
// entry_address is not NULL, it will be set to the address that the entry
// was stored at.
- bool Retrieve(const AddressType &address,
- const EntryType *&entry, AddressType *entry_address) const;
+ bool Retrieve(const AddressType& address,
+ const EntryType*& entry, AddressType* entry_address) const;
private:
friend class ModuleComparer;
diff --git a/src/processor/static_address_map_unittest.cc b/src/processor/static_address_map_unittest.cc
index 12c735c..9f1215d 100644
--- a/src/processor/static_address_map_unittest.cc
+++ b/src/processor/static_address_map_unittest.cc
@@ -95,7 +95,7 @@
int address_test;
string entry;
string entry_test;
- const char *entry_cstring = NULL;
+ const char* entry_cstring = NULL;
bool found;
bool found_test;
@@ -143,11 +143,11 @@
// Test data sets:
static const int kNumberTestCases = 4;
static const int testsize[];
- int *testdata[kNumberTestCases];
+ int* testdata[kNumberTestCases];
AddrMap addr_map[kNumberTestCases];
TestMap test_map[kNumberTestCases];
- char *map_data[kNumberTestCases];
+ char* map_data[kNumberTestCases];
google_breakpad::AddressMapSerializer<int, string> serializer;
};
@@ -229,7 +229,7 @@
}
}
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
diff --git a/src/processor/static_contained_range_map-inl.h b/src/processor/static_contained_range_map-inl.h
index 777c762..87ea6c7 100644
--- a/src/processor/static_contained_range_map-inl.h
+++ b/src/processor/static_contained_range_map-inl.h
@@ -47,7 +47,7 @@
const char *base)
: base_(*(reinterpret_cast<const AddressType*>(base))),
entry_size_(*(reinterpret_cast<const uint32_t*>(base + sizeof(base_)))),
- entry_ptr_(reinterpret_cast<const EntryType *>(
+ entry_ptr_(reinterpret_cast<const EntryType*>(
base + sizeof(base_) + sizeof(entry_size_))),
map_(base + sizeof(base_) + sizeof(entry_size_) + entry_size_) {
if (entry_size_ == 0)
@@ -57,7 +57,7 @@
template<typename AddressType, typename EntryType>
bool StaticContainedRangeMap<AddressType, EntryType>::RetrieveRange(
- const AddressType &address, const EntryType *&entry) const {
+ const AddressType& address, const EntryType*& entry) const {
// Get an iterator to the child range whose high address is equal to or
// greater than the supplied address. If the supplied address is higher
diff --git a/src/processor/static_contained_range_map.h b/src/processor/static_contained_range_map.h
index 6a9b8b7..14fa5e9 100644
--- a/src/processor/static_contained_range_map.h
+++ b/src/processor/static_contained_range_map.h
@@ -57,7 +57,7 @@
// child ranges, and not the entry contained by |this|. This is necessary
// to support a sparsely-populated root range. If no descendant range
// encompasses the address, returns false.
- bool RetrieveRange(const AddressType &address, const EntryType *&entry) const;
+ bool RetrieveRange(const AddressType& address, const EntryType*& entry) const;
private:
friend class ModuleComparer;
diff --git a/src/processor/static_map-inl.h b/src/processor/static_map-inl.h
index e6aac6a..75a8a33 100644
--- a/src/processor/static_map-inl.h
+++ b/src/processor/static_map-inl.h
@@ -59,7 +59,7 @@
// find(), lower_bound() and upper_bound() implement binary search algorithm.
template<typename Key, typename Value, typename Compare>
StaticMapIterator<Key, Value, Compare>
-StaticMap<Key, Value, Compare>::find(const Key &key) const {
+StaticMap<Key, Value, Compare>::find(const Key& key) const {
int begin = 0;
int end = num_nodes_;
int middle;
@@ -80,7 +80,7 @@
template<typename Key, typename Value, typename Compare>
StaticMapIterator<Key, Value, Compare>
-StaticMap<Key, Value, Compare>::lower_bound(const Key &key) const {
+StaticMap<Key, Value, Compare>::lower_bound(const Key& key) const {
int begin = 0;
int end = num_nodes_;
int middle;
@@ -101,7 +101,7 @@
template<typename Key, typename Value, typename Compare>
StaticMapIterator<Key, Value, Compare>
-StaticMap<Key, Value, Compare>::upper_bound(const Key &key) const {
+StaticMap<Key, Value, Compare>::upper_bound(const Key& key) const {
int begin = 0;
int end = num_nodes_;
int middle;
diff --git a/src/processor/static_map.h b/src/processor/static_map.h
index 9723ab2..e7d8c96 100644
--- a/src/processor/static_map.h
+++ b/src/processor/static_map.h
@@ -72,7 +72,7 @@
template<typename Key>
class DefaultCompare {
public:
- int operator()(const Key &k1, const Key &k2) const {
+ int operator()(const Key& k1, const Key& k2) const {
if (k1 < k2) return -1;
if (k1 == k2) return 0;
return 1;
@@ -104,15 +104,15 @@
}
// Lookup operations.
- iterator find(const Key &k) const;
+ iterator find(const Key& k) const;
// lower_bound(k) searches in a sorted range for the first element that has a
// key not less than the argument k.
- iterator lower_bound(const Key &k) const;
+ iterator lower_bound(const Key& k) const;
// upper_bound(k) searches in a sorted range for the first element that has a
// key greater than the argument k.
- iterator upper_bound(const Key &k) const;
+ iterator upper_bound(const Key& k) const;
// Checks if the underlying memory data conforms to the predefined pattern:
// first check the number of nodes is non-negative,
diff --git a/src/processor/static_map_iterator-inl.h b/src/processor/static_map_iterator-inl.h
index 7a7db5a..8474584 100644
--- a/src/processor/static_map_iterator-inl.h
+++ b/src/processor/static_map_iterator-inl.h
@@ -43,7 +43,7 @@
template<typename Key, typename Value, typename Compare>
StaticMapIterator<Key, Value, Compare>::StaticMapIterator(const char* base,
- const int &index):
+ const int& index):
index_(index), base_(base) {
// See static_map.h for documentation on
// bytes format of serialized StaticMap data.
diff --git a/src/processor/static_map_iterator.h b/src/processor/static_map_iterator.h
index 1af8fff..c49a8b7 100644
--- a/src/processor/static_map_iterator.h
+++ b/src/processor/static_map_iterator.h
@@ -87,7 +87,7 @@
friend class StaticMap<Key, Value, Compare>;
// Only StaticMap can call this constructor.
- explicit StaticMapIterator(const char* base, const int32_t &index);
+ explicit StaticMapIterator(const char* base, const int32_t& index);
// Index of node that the iterator is pointing to.
int32_t index_;
diff --git a/src/processor/static_map_unittest.cc b/src/processor/static_map_unittest.cc
index 393d43d..d17153d 100644
--- a/src/processor/static_map_unittest.cc
+++ b/src/processor/static_map_unittest.cc
@@ -46,7 +46,7 @@
template<typename Key, typename Value>
class SimpleMapSerializer {
public:
- static char* Serialize(const std::map<Key, Value> &stdmap,
+ static char* Serialize(const std::map<Key, Value>& stdmap,
unsigned int* size = NULL) {
unsigned int size_per_node =
sizeof(uint32_t) + sizeof(Key) + sizeof(Value);
@@ -237,19 +237,19 @@
}
}
- void FindTester(int test_case, const KeyType &key) {
+ void FindTester(int test_case, const KeyType& key) {
iter_test = test_map[test_case].find(key);
iter_std = std_map[test_case].find(key);
CompareLookupResult(test_case);
}
- void LowerBoundTester(int test_case, const KeyType &key) {
+ void LowerBoundTester(int test_case, const KeyType& key) {
iter_test = test_map[test_case].lower_bound(key);
iter_std = std_map[test_case].lower_bound(key);
CompareLookupResult(test_case);
}
- void UpperBoundTester(int test_case, const KeyType &key) {
+ void UpperBoundTester(int test_case, const KeyType& key) {
iter_test = test_map[test_case].upper_bound(key);
iter_std = std_map[test_case].upper_bound(key);
CompareLookupResult(test_case);
diff --git a/src/processor/static_range_map-inl.h b/src/processor/static_range_map-inl.h
index f6cef1a..37fb6fa 100644
--- a/src/processor/static_range_map-inl.h
+++ b/src/processor/static_range_map-inl.h
@@ -43,8 +43,8 @@
template<typename AddressType, typename EntryType>
bool StaticRangeMap<AddressType, EntryType>::RetrieveRange(
- const AddressType &address, const EntryType *&entry,
- AddressType *entry_base, AddressType *entry_size) const {
+ const AddressType& address, const EntryType*& entry,
+ AddressType* entry_base, AddressType* entry_size) const {
MapConstIterator iterator = map_.lower_bound(address);
if (iterator == map_.end())
return false;
@@ -55,7 +55,7 @@
// be below the range's low address, though. When that happens, address
// references something not within any range, so return false.
- const Range *range = iterator.GetValuePtr();
+ const Range* range = iterator.GetValuePtr();
// Make sure AddressType and EntryType are copyable basic types
// e.g.: integer types, pointers etc
@@ -74,8 +74,8 @@
template<typename AddressType, typename EntryType>
bool StaticRangeMap<AddressType, EntryType>::RetrieveNearestRange(
- const AddressType &address, const EntryType *&entry,
- AddressType *entry_base, AddressType *entry_size) const {
+ const AddressType& address, const EntryType*& entry,
+ AddressType* entry_base, AddressType* entry_size) const {
// If address is within a range, RetrieveRange can handle it.
if (RetrieveRange(address, entry, entry_base, entry_size))
return true;
@@ -91,7 +91,7 @@
return false;
--iterator;
- const Range *range = iterator.GetValuePtr();
+ const Range* range = iterator.GetValuePtr();
entry = range->entryptr();
if (entry_base)
*entry_base = range->base();
@@ -103,8 +103,8 @@
template<typename AddressType, typename EntryType>
bool StaticRangeMap<AddressType, EntryType>::RetrieveRangeAtIndex(
- int index, const EntryType *&entry,
- AddressType *entry_base, AddressType *entry_size) const {
+ int index, const EntryType*& entry,
+ AddressType* entry_base, AddressType* entry_size) const {
if (index >= GetCount()) {
BPLOG(ERROR) << "Index out of range: " << index << "/" << GetCount();
@@ -113,7 +113,7 @@
MapConstIterator iterator = map_.IteratorAtIndex(index);
- const Range *range = iterator.GetValuePtr();
+ const Range* range = iterator.GetValuePtr();
entry = range->entryptr();
if (entry_base)
diff --git a/src/processor/static_range_map.h b/src/processor/static_range_map.h
index 91aabb0..ea89fae 100644
--- a/src/processor/static_range_map.h
+++ b/src/processor/static_range_map.h
@@ -50,21 +50,21 @@
class StaticRangeMap {
public:
StaticRangeMap(): map_() { }
- explicit StaticRangeMap(const char *memory): map_(memory) { }
+ explicit StaticRangeMap(const char* memory): map_(memory) { }
// Locates the range encompassing the supplied address. If there is
// no such range, returns false. entry_base and entry_size, if non-NULL,
// are set to the base and size of the entry's range.
- bool RetrieveRange(const AddressType &address, const EntryType *&entry,
- AddressType *entry_base, AddressType *entry_size) const;
+ bool RetrieveRange(const AddressType& address, const EntryType*& entry,
+ AddressType* entry_base, AddressType* entry_size) const;
// Locates the range encompassing the supplied address, if one exists.
// If no range encompasses the supplied address, locates the nearest range
// to the supplied address that is lower than the address. Returns false
// if no range meets these criteria. entry_base and entry_size, if
// non-NULL, are set to the base and size of the entry's range.
- bool RetrieveNearestRange(const AddressType &address, const EntryType *&entry,
- AddressType *entry_base, AddressType *entry_size)
+ bool RetrieveNearestRange(const AddressType& address, const EntryType*& entry,
+ AddressType* entry_base, AddressType* entry_size)
const;
// Treating all ranges as a list ordered by the address spaces that they
@@ -74,8 +74,8 @@
// range.
//
// RetrieveRangeAtIndex is not optimized for speedy operation.
- bool RetrieveRangeAtIndex(int index, const EntryType *&entry,
- AddressType *entry_base, AddressType *entry_size)
+ bool RetrieveRangeAtIndex(int index, const EntryType*& entry,
+ AddressType* entry_base, AddressType* entry_size)
const;
// Returns the number of ranges stored in the RangeMap.
diff --git a/src/processor/static_range_map_unittest.cc b/src/processor/static_range_map_unittest.cc
index 2821736..1593ed0 100644
--- a/src/processor/static_range_map_unittest.cc
+++ b/src/processor/static_range_map_unittest.cc
@@ -414,7 +414,7 @@
} // namespace google_breakpad
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
diff --git a/src/processor/synth_minidump.cc b/src/processor/synth_minidump.cc
index 5e72c16..da61afc 100644
--- a/src/processor/synth_minidump.cc
+++ b/src/processor/synth_minidump.cc
@@ -37,7 +37,7 @@
namespace SynthMinidump {
-Section::Section(const Dump &dump)
+Section::Section(const Dump& dump)
: test_assembler::Section(dump.endianness()) { }
void Section::CiteLocationIn(test_assembler::Section *section) const {
@@ -49,9 +49,9 @@
CiteLocationIn(section);
}
-SystemInfo::SystemInfo(const Dump &dump,
- const MDRawSystemInfo &system_info,
- const String &csd_version)
+SystemInfo::SystemInfo(const Dump& dump,
+ const MDRawSystemInfo& system_info,
+ const String& csd_version)
: Stream(dump, MD_SYSTEM_INFO_STREAM) {
D16(system_info.processor_architecture);
D16(system_info.processor_level);
@@ -108,7 +108,7 @@
const string SystemInfo::windows_x86_csd_version = "Service Pack 2";
-String::String(const Dump &dump, const string &contents) : Section(dump) {
+String::String(const Dump& dump, const string& contents) : Section(dump) {
D32(contents.size() * 2);
for (string::const_iterator i = contents.begin(); i != contents.end(); i++)
D16(*i);
@@ -123,7 +123,7 @@
CiteLocationIn(section);
}
-Context::Context(const Dump &dump, const MDRawContextX86 &context)
+Context::Context(const Dump& dump, const MDRawContextX86& context)
: Section(dump) {
// The caller should have properly set the CPU type flag.
// The high 24 bits identify the CPU. Note that context records with no CPU
@@ -173,7 +173,7 @@
assert(Size() == sizeof(MDRawContextX86));
}
-Context::Context(const Dump &dump, const MDRawContextARM &context)
+Context::Context(const Dump& dump, const MDRawContextARM& context)
: Section(dump) {
// The caller should have properly set the CPU type flag.
assert((context.context_flags & MD_CONTEXT_ARM) ||
@@ -192,7 +192,7 @@
assert(Size() == sizeof(MDRawContextARM));
}
-Context::Context(const Dump &dump, const MDRawContextMIPS &context)
+Context::Context(const Dump& dump, const MDRawContextMIPS& context)
: Section(dump) {
// The caller should have properly set the CPU type flag.
assert(context.context_flags & MD_CONTEXT_MIPS);
@@ -228,8 +228,8 @@
assert(Size() == sizeof(MDRawContextMIPS));
}
-Thread::Thread(const Dump &dump,
- uint32_t thread_id, const Memory &stack, const Context &context,
+Thread::Thread(const Dump& dump,
+ uint32_t thread_id, const Memory& stack, const Context& context,
uint32_t suspend_count, uint32_t priority_class,
uint32_t priority, uint64_t teb) : Section(dump) {
D32(thread_id);
@@ -242,13 +242,13 @@
assert(Size() == sizeof(MDRawThread));
}
-Module::Module(const Dump &dump,
+Module::Module(const Dump& dump,
uint64_t base_of_image,
uint32_t size_of_image,
- const String &name,
+ const String& name,
uint32_t time_date_stamp,
uint32_t checksum,
- const MDVSFixedFileInfo &version_info,
+ const MDVSFixedFileInfo& version_info,
const Section *cv_record,
const Section *misc_record) : Section(dump) {
D64(base_of_image);
@@ -297,10 +297,10 @@
0 // file_date_lo
};
-UnloadedModule::UnloadedModule(const Dump &dump,
+UnloadedModule::UnloadedModule(const Dump& dump,
uint64_t base_of_image,
uint32_t size_of_image,
- const String &name,
+ const String& name,
uint32_t checksum,
uint32_t time_date_stamp) : Section(dump) {
D64(base_of_image);
@@ -310,15 +310,15 @@
name.CiteStringIn(this);
}
-UnloadedModuleList::UnloadedModuleList(const Dump &dump, uint32_t type)
+UnloadedModuleList::UnloadedModuleList(const Dump& dump, uint32_t type)
: List<UnloadedModule>(dump, type, false) {
D32(sizeof(MDRawUnloadedModuleList));
D32(sizeof(MDRawUnloadedModule));
D32(count_label_);
}
-Exception::Exception(const Dump &dump,
- const Context &context,
+Exception::Exception(const Dump& dump,
+ const Context& context,
uint32_t thread_id,
uint32_t exception_code,
uint32_t exception_flags,
@@ -361,22 +361,22 @@
assert(Size() == sizeof(MDRawHeader));
}
-Dump &Dump::Add(SynthMinidump::Section *section) {
+Dump& Dump::Add(SynthMinidump::Section *section) {
section->Finish(file_start_ + Size());
Append(*section);
return *this;
}
-Dump &Dump::Add(Stream *stream) {
- Add(static_cast<SynthMinidump::Section *>(stream));
+Dump& Dump::Add(Stream *stream) {
+ Add(static_cast<SynthMinidump::Section*>(stream));
stream->CiteStreamIn(&stream_directory_);
stream_count_++;
return *this;
}
-Dump &Dump::Add(Memory *memory) {
+Dump& Dump::Add(Memory *memory) {
// Add the memory contents themselves to the file.
- Add(static_cast<SynthMinidump::Section *>(memory));
+ Add(static_cast<SynthMinidump::Section*>(memory));
// The memory list is a list of MDMemoryDescriptors, not of actual
// memory elements. Produce a descriptor, and add that to the list.
@@ -386,17 +386,17 @@
return *this;
}
-Dump &Dump::Add(Thread *thread) {
+Dump& Dump::Add(Thread *thread) {
thread_list_.Add(thread);
return *this;
}
-Dump &Dump::Add(Module *module) {
+Dump& Dump::Add(Module *module) {
module_list_.Add(module);
return *this;
}
-Dump &Dump::Add(UnloadedModule *unloaded_module) {
+Dump& Dump::Add(UnloadedModule *unloaded_module) {
unloaded_module_list_.Add(unloaded_module);
return *this;
}
@@ -413,7 +413,7 @@
// has the stream count and MDRVA.
stream_count_label_ = stream_count_;
stream_directory_rva_ = file_start_ + Size();
- Append(static_cast<test_assembler::Section &>(stream_directory_));
+ Append(static_cast<test_assembler::Section& >(stream_directory_));
}
} // namespace SynthMinidump
diff --git a/src/processor/synth_minidump.h b/src/processor/synth_minidump.h
index 8f49cff..2da4d5f 100644
--- a/src/processor/synth_minidump.h
+++ b/src/processor/synth_minidump.h
@@ -135,7 +135,7 @@
// A test_assembler::Section which will be appended to a minidump.
class Section: public test_assembler::Section {
public:
- explicit Section(const Dump &dump);
+ explicit Section(const Dump& dump);
// Append an MDLocationDescriptor referring to this section to SECTION.
// If 'this' is NULL, append a descriptor with a zero length and MDRVA.
@@ -145,13 +145,13 @@
// bad, if such language exists. Having this function handle NULL
// 'this' is convenient, but if it causes trouble, it's not hard to
// do differently.)
- void CiteLocationIn(test_assembler::Section *section) const;
+ void CiteLocationIn(test_assembler::Section* section) const;
// Note that this section's contents are complete, and that it has
// been placed in the minidump file at OFFSET. The 'Add' member
// functions call the Finish member function of the object being
// added for you; if you are 'Add'ing this section, you needn't Finish it.
- virtual void Finish(const Label &offset) {
+ virtual void Finish(const Label& offset) {
file_offset_ = offset; size_ = Size();
}
@@ -166,10 +166,10 @@
public:
// Create a stream of type TYPE. You can append whatever contents
// you like to this stream using the test_assembler::Section methods.
- Stream(const Dump &dump, uint32_t type) : Section(dump), type_(type) { }
+ Stream(const Dump& dump, uint32_t type) : Section(dump), type_(type) { }
// Append an MDRawDirectory referring to this stream to SECTION.
- void CiteStreamIn(test_assembler::Section *section) const;
+ void CiteStreamIn(test_assembler::Section* section) const;
private:
// The type of this stream.
@@ -186,9 +186,9 @@
//
// Remember that you are still responsible for 'Add'ing CSD_VERSION
// to the dump yourself.
- SystemInfo(const Dump &dump,
- const MDRawSystemInfo &system_info,
- const String &csd_version);
+ SystemInfo(const Dump& dump,
+ const MDRawSystemInfo& system_info,
+ const String& csd_version);
// Stock MDRawSystemInfo information and associated strings, for
// writing tests.
@@ -199,10 +199,10 @@
// An MDString: a string preceded by a 32-bit length.
class String: public Section {
public:
- String(const Dump &dump, const string &value);
+ String(const Dump& dump, const string& value);
// Append an MDRVA referring to this string to SECTION.
- void CiteStringIn(test_assembler::Section *section) const;
+ void CiteStringIn(test_assembler::Section* section) const;
};
// A range of memory contents. 'Add'ing a memory range to a minidump
@@ -211,11 +211,11 @@
// to memory addresses.
class Memory: public Section {
public:
- Memory(const Dump &dump, uint64_t address)
+ Memory(const Dump& dump, uint64_t address)
: Section(dump), address_(address) { start() = address; }
// Append an MDMemoryDescriptor referring to this memory range to SECTION.
- void CiteMemoryIn(test_assembler::Section *section) const;
+ void CiteMemoryIn(test_assembler::Section* section) const;
private:
// The process address from which these memory contents were taken.
@@ -226,11 +226,11 @@
class Context: public Section {
public:
// Create a context belonging to DUMP whose contents are a copy of CONTEXT.
- Context(const Dump &dump, const MDRawContextX86 &context);
- Context(const Dump &dump, const MDRawContextARM &context);
- Context(const Dump &dump, const MDRawContextMIPS &context);
+ Context(const Dump& dump, const MDRawContextX86& context);
+ Context(const Dump& dump, const MDRawContextARM& context);
+ Context(const Dump& dump, const MDRawContextMIPS& context);
// Add an empty context to the dump.
- Context(const Dump &dump) : Section(dump) {}
+ Context(const Dump& dump) : Section(dump) {}
// Add constructors for other architectures here. Remember to byteswap.
};
@@ -238,10 +238,10 @@
public:
// Create a thread belonging to DUMP with the given values, citing
// STACK and CONTEXT (which you must Add to the dump separately).
- Thread(const Dump &dump,
+ Thread(const Dump& dump,
uint32_t thread_id,
- const Memory &stack,
- const Context &context,
+ const Memory& stack,
+ const Context& context,
uint32_t suspend_count = 0,
uint32_t priority_class = 0,
uint32_t priority = 0,
@@ -253,15 +253,15 @@
// Create a module with the given values. Note that CV_RECORD and
// MISC_RECORD can be NULL, in which case the corresponding location
// descriptior in the minidump will have a length of zero.
- Module(const Dump &dump,
+ Module(const Dump& dump,
uint64_t base_of_image,
uint32_t size_of_image,
- const String &name,
+ const String& name,
uint32_t time_date_stamp = 1262805309,
uint32_t checksum = 0,
- const MDVSFixedFileInfo &version_info = Module::stock_version_info,
- const Section *cv_record = NULL,
- const Section *misc_record = NULL);
+ const MDVSFixedFileInfo& version_info = Module::stock_version_info,
+ const Section* cv_record = NULL,
+ const Section* misc_record = NULL);
private:
// A standard MDVSFixedFileInfo structure to use as a default for
@@ -272,18 +272,18 @@
class UnloadedModule: public Section {
public:
- UnloadedModule(const Dump &dump,
+ UnloadedModule(const Dump& dump,
uint64_t base_of_image,
uint32_t size_of_image,
- const String &name,
+ const String& name,
uint32_t checksum = 0,
uint32_t time_date_stamp = 1262805309);
};
class Exception : public Stream {
public:
- Exception(const Dump &dump,
- const Context &context,
+ Exception(const Dump& dump,
+ const Context& context,
uint32_t thread_id = 0,
uint32_t exception_code = 0,
uint32_t exception_flags = 0,
@@ -295,12 +295,12 @@
template<typename Element>
class List: public Stream {
public:
- List(const Dump &dump, uint32_t type) : Stream(dump, type), count_(0) {
+ List(const Dump& dump, uint32_t type) : Stream(dump, type), count_(0) {
D32(count_label_);
}
// Add ELEMENT to this list.
- void Add(Element *element) {
+ void Add(Element* element) {
element->Finish(file_offset_ + Size());
Append(*element);
count_++;
@@ -311,7 +311,7 @@
// Finish up the contents of this section, mark it as having been
// placed at OFFSET.
- virtual void Finish(const Label &offset) {
+ virtual void Finish(const Label& offset) {
Stream::Finish(offset);
count_label_ = count_;
}
@@ -322,14 +322,14 @@
protected:
// This constructor allows derived lists to specify their own layout
// rather than starting with count as specified in the public constructor.
- List(const Dump &dump, uint32_t type, bool) : Stream(dump, type), count_(0) {}
+ List(const Dump& dump, uint32_t type, bool) : Stream(dump, type), count_(0) {}
Label count_label_;
};
class UnloadedModuleList : public List<UnloadedModule> {
public:
- UnloadedModuleList(const Dump &dump, uint32_t type);
+ UnloadedModuleList(const Dump& dump, uint32_t type);
};
class Dump: public test_assembler::Section {
@@ -349,12 +349,12 @@
// whatever directory or list is appropriate for its type. The
// stream directory, memory list, thread list, and module list are
// accumulated this way.
- Dump &Add(SynthMinidump::Section *object); // simply append data
- Dump &Add(Stream *object); // append, record in stream directory
- Dump &Add(Memory *object); // append, record in memory list
- Dump &Add(Thread *object); // append, record in thread list
- Dump &Add(Module *object); // append, record in module list
- Dump &Add(UnloadedModule *object); // append, record in unloaded module list
+ Dump& Add(SynthMinidump::Section* object); // simply append data
+ Dump& Add(Stream* object); // append, record in stream directory
+ Dump& Add(Memory* object); // append, record in memory list
+ Dump& Add(Thread* object); // append, record in thread list
+ Dump& Add(Module* object); // append, record in module list
+ Dump& Add(UnloadedModule* object); // append, record in unloaded module list
// Complete the construction of the minidump, given the Add calls
// we've seen up to this point. After this call, this Dump's
@@ -367,26 +367,26 @@
Label file_start_;
// The stream directory. We construct this incrementally from
- // Add(Stream *) calls.
+ // Add(Stream*) calls.
SynthMinidump::Section stream_directory_; // The directory's contents.
size_t stream_count_; // The number of streams so far.
Label stream_count_label_; // Cited in file header.
Label stream_directory_rva_; // The directory's file offset.
// This minidump's thread list. We construct this incrementally from
- // Add(Thread *) calls.
+ // Add(Thread*) calls.
List<Thread> thread_list_;
// This minidump's module list. We construct this incrementally from
- // Add(Module *) calls.
+ // Add(Module*) calls.
List<Module> module_list_;
// This minidump's unloaded module list. We construct this incrementally from
- // Add(UnloadedModule *) calls.
+ // Add(UnloadedModule*) calls.
UnloadedModuleList unloaded_module_list_;
// This minidump's memory list. We construct this incrementally from
- // Add(Memory *) calls. This is actually a list of MDMemoryDescriptors,
+ // Add(Memory*) calls. This is actually a list of MDMemoryDescriptors,
// not memory ranges --- thus the odd type.
List<SynthMinidump::Section> memory_list_;
};
diff --git a/src/processor/testdata/linux_test_app.cc b/src/processor/testdata/linux_test_app.cc
index 18f0f62..9df6dcc 100644
--- a/src/processor/testdata/linux_test_app.cc
+++ b/src/processor/testdata/linux_test_app.cc
@@ -51,8 +51,8 @@
namespace {
// google_breakpad::MinidumpCallback to invoke after minidump generation.
-static bool callback(const char *dump_path, const char *id,
- void *context,
+static bool callback(const char* dump_path, const char* id,
+ void* context,
bool succeeded) {
if (succeeded) {
printf("dump guid is %s\n", id);
@@ -65,13 +65,13 @@
}
static void CrashFunction() {
- int *i = reinterpret_cast<int*>(0x45);
+ int* i = reinterpret_cast<int*>(0x45);
*i = 5; // crash!
}
} // namespace
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
google_breakpad::ExceptionHandler eh(".", NULL, callback, NULL, true);
if (!eh.WriteMinidump()) {
printf("Failed to generate on-demand minidump\n");
diff --git a/src/processor/testdata/test_app.cc b/src/processor/testdata/test_app.cc
index 7882a8b..c744a37 100644
--- a/src/processor/testdata/test_app.cc
+++ b/src/processor/testdata/test_app.cc
@@ -38,9 +38,9 @@
namespace {
-static bool callback(const wchar_t *dump_path, const wchar_t *id,
- void *context, EXCEPTION_POINTERS *exinfo,
- MDRawAssertionInfo *assertion,
+static bool callback(const wchar_t* dump_path, const wchar_t* id,
+ void* context, EXCEPTION_POINTERS* exinfo,
+ MDRawAssertionInfo* assertion,
bool succeeded) {
if (succeeded) {
printf("dump guid is %ws\n", id);
@@ -53,13 +53,13 @@
}
static void CrashFunction() {
- int *i = reinterpret_cast<int*>(0x45);
+ int* i = reinterpret_cast<int*>(0x45);
*i = 5; // crash!
}
} // namespace
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
google_breakpad::ExceptionHandler eh(
L".", NULL, callback, NULL,
google_breakpad::ExceptionHandler::HANDLER_ALL);
diff --git a/src/processor/tokenize.cc b/src/processor/tokenize.cc
index 8fce87a..29e8125 100644
--- a/src/processor/tokenize.cc
+++ b/src/processor/tokenize.cc
@@ -42,10 +42,10 @@
using std::vector;
-bool Tokenize(char *line,
- const char *separators,
- int max_tokens,
- vector<char*> *tokens) {
+bool Tokenize(char* line,
+ const char* separators,
+ int max_tokens,
+ vector<char*>* tokens) {
tokens->clear();
tokens->reserve(max_tokens);
@@ -53,8 +53,8 @@
// Split tokens on the separator character.
// strip them out before exhausting max_tokens.
- char *save_ptr;
- char *token = strtok_r(line, separators, &save_ptr);
+ char* save_ptr;
+ char* token = strtok_r(line, separators, &save_ptr);
while (token && --remaining > 0) {
tokens->push_back(token);
if (remaining > 1)
@@ -69,10 +69,9 @@
return tokens->size() == static_cast<unsigned int>(max_tokens);
}
-void StringToVector(const string &str, vector<char> &vec) {
+void StringToVector(const string& str, vector<char>& vec) {
vec.resize(str.length() + 1);
- std::copy(str.begin(), str.end(),
- vec.begin());
+ std::copy(str.begin(), str.end(), vec.begin());
vec[str.length()] = '\0';
}
diff --git a/src/processor/tokenize.h b/src/processor/tokenize.h
index 9ff571d..c4480aa 100644
--- a/src/processor/tokenize.h
+++ b/src/processor/tokenize.h
@@ -50,13 +50,13 @@
// Tokenize, but may be treated as a failure if the caller expects an
// exact, as opposed to maximum, number of tokens.
-bool Tokenize(char *line,
- const char *separators,
+bool Tokenize(char* line,
+ const char* separators,
int max_tokens,
- std::vector<char*> *tokens);
+ std::vector<char*>* tokens);
// For convenience, since you need a char* to pass to Tokenize.
// You can call StringToVector on a string, and use &vec[0].
-void StringToVector(const string &str, std::vector<char> &vec);
+void StringToVector(const string& str, std::vector<char>& vec);
} // namespace google_breakpad
diff --git a/src/processor/windows_frame_info.h b/src/processor/windows_frame_info.h
index f96e0a4..993832a 100644
--- a/src/processor/windows_frame_info.h
+++ b/src/processor/windows_frame_info.h
@@ -113,9 +113,9 @@
// otherwise. type, rva and code_size are present in the STACK line,
// but not the StackFrameInfo structure, so return them as outparams.
static WindowsFrameInfo *ParseFromString(const string string,
- int &type,
- uint64_t &rva,
- uint64_t &code_size) {
+ int& type,
+ uint64_t& rva,
+ uint64_t& code_size) {
// The format of a STACK WIN record is documented at:
//
// https://chromium.googlesource.com/breakpad/breakpad/+/master/docs/symbol_files.md
@@ -160,7 +160,7 @@
}
// CopyFrom makes "this" WindowsFrameInfo object identical to "that".
- void CopyFrom(const WindowsFrameInfo &that) {
+ void CopyFrom(const WindowsFrameInfo& that) {
type_ = that.type_;
valid = that.valid;
prolog_size = that.prolog_size;
diff --git a/src/tools/linux/dump_syms/dump_syms.cc b/src/tools/linux/dump_syms/dump_syms.cc
index ebdf231..42e582c 100644
--- a/src/tools/linux/dump_syms/dump_syms.cc
+++ b/src/tools/linux/dump_syms/dump_syms.cc
@@ -56,7 +56,7 @@
return 1;
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
if (argc < 2)
return usage(argv[0]);
bool header_only = false;
diff --git a/src/tools/linux/md2core/minidump-2-core.cc b/src/tools/linux/md2core/minidump-2-core.cc
index a60be32..aade82c 100644
--- a/src/tools/linux/md2core/minidump-2-core.cc
+++ b/src/tools/linux/md2core/minidump-2-core.cc
@@ -149,7 +149,7 @@
options->use_filename = false;
options->inc_guid = false;
- while ((ch = getopt(argc, (char * const *)argv, "fhio:S:v")) != -1) {
+ while ((ch = getopt(argc, (char * const*)argv, "fhio:S:v")) != -1) {
switch (ch) {
case 'h':
Usage(argc, argv);
@@ -224,7 +224,7 @@
*/
static inline int sex() {
int probe = 1;
- return !*(char *)&probe;
+ return !*(char*)&probe;
}
typedef struct elf_timeval { /* Time value with microsecond resolution */
@@ -660,10 +660,10 @@
sysinfo->processor_architecture == MD_CPU_ARCHITECTURE_AMD64) {
fputs("Vendor id: ", stderr);
const char *nul =
- (const char *)memchr(sysinfo->cpu.x86_cpu_info.vendor_id, 0,
+ (const char*)memchr(sysinfo->cpu.x86_cpu_info.vendor_id, 0,
sizeof(sysinfo->cpu.x86_cpu_info.vendor_id));
fwrite(sysinfo->cpu.x86_cpu_info.vendor_id,
- nul ? nul - (const char *)&sysinfo->cpu.x86_cpu_info.vendor_id[0]
+ nul ? nul - (const char*)&sysinfo->cpu.x86_cpu_info.vendor_id[0]
: sizeof(sysinfo->cpu.x86_cpu_info.vendor_id), 1, stderr);
fputs("\n", stderr);
}
@@ -759,7 +759,7 @@
memcpy(env, range.data(), range.length());
int nul_count = 0;
for (char *ptr = env;;) {
- ptr = (char *)memchr(ptr, '\000', range.length() - (ptr - env));
+ ptr = (char*)memchr(ptr, '\000', range.length() - (ptr - env));
if (!ptr) {
break;
}
@@ -1076,7 +1076,7 @@
for (unsigned i = 0; i < crashinfo->threads.size(); ++i) {
const CrashedProcess::Thread& thread = crashinfo->threads[i];
AddDataToMapping(crashinfo,
- string((char *)thread.stack, thread.stack_length),
+ string((char*)thread.stack, thread.stack_length),
thread.stack_addr);
}
diff --git a/src/tools/linux/symupload/minidump_upload.cc b/src/tools/linux/symupload/minidump_upload.cc
index 19f1745..f24e971 100644
--- a/src/tools/linux/symupload/minidump_upload.cc
+++ b/src/tools/linux/symupload/minidump_upload.cc
@@ -111,7 +111,7 @@
extern int optind;
int ch;
- while ((ch = getopt(argc, (char * const *)argv, "p:u:v:x:h?")) != -1) {
+ while ((ch = getopt(argc, (char * const*)argv, "p:u:v:x:h?")) != -1) {
switch (ch) {
case 'p':
options->product = optarg;
diff --git a/src/tools/linux/symupload/sym_upload.cc b/src/tools/linux/symupload/sym_upload.cc
index 256f73c..57df81c 100644
--- a/src/tools/linux/symupload/sym_upload.cc
+++ b/src/tools/linux/symupload/sym_upload.cc
@@ -115,7 +115,7 @@
int ch;
constexpr char flag_pattern[] = "u:v:x:p:k:t:c:i:hf?";
- while ((ch = getopt(argc, (char * const *)argv, flag_pattern)) != -1) {
+ while ((ch = getopt(argc, (char * const*)argv, flag_pattern)) != -1) {
switch (ch) {
case 'h':
case '?':
diff --git a/src/tools/mac/crash_report/on_demand_symbol_supplier.h b/src/tools/mac/crash_report/on_demand_symbol_supplier.h
index 3fbe108..69b4140 100644
--- a/src/tools/mac/crash_report/on_demand_symbol_supplier.h
+++ b/src/tools/mac/crash_report/on_demand_symbol_supplier.h
@@ -47,30 +47,30 @@
public:
// |search_dir| is the directory to search for alternative symbols with
// the same name as the module in the minidump
- OnDemandSymbolSupplier(const string &search_dir,
- const string &symbol_search_dir);
+ OnDemandSymbolSupplier(const string& search_dir,
+ const string& symbol_search_dir);
virtual ~OnDemandSymbolSupplier() {}
// Returns the path to the symbol file for the given module.
- virtual SymbolResult GetSymbolFile(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file);
+ virtual SymbolResult GetSymbolFile(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file);
// Returns the path to the symbol file for the given module.
- virtual SymbolResult GetSymbolFile(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file,
- string *symbol_data);
+ virtual SymbolResult GetSymbolFile(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file,
+ string* symbol_data);
// Allocates data buffer on heap, and takes the ownership of
// the data buffer.
- virtual SymbolResult GetCStringSymbolData(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file,
- char **symbol_data,
- size_t *symbol_data_size);
+ virtual SymbolResult GetCStringSymbolData(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file,
+ char** symbol_data,
+ size_t* symbol_data_size);
// Delete the data buffer allocated for module in GetCStringSymbolData().
- virtual void FreeSymbolData(const CodeModule *module);
+ virtual void FreeSymbolData(const CodeModule* module);
protected:
// Search directory
@@ -82,28 +82,28 @@
map<string, string> module_file_map_;
// Map of allocated data buffers, keyed by module->code_file().
- map<string, char *> memory_buffers_;
+ map<string, char*> memory_buffers_;
// Return the name for |module| This will be the value used as the key
// to the |module_file_map_|.
- string GetNameForModule(const CodeModule *module);
+ string GetNameForModule(const CodeModule* module);
// Find the module on local system. If the module resides in a different
// location than the full path in the minidump, this will be the location
// used.
- string GetLocalModulePath(const CodeModule *module);
+ string GetLocalModulePath(const CodeModule* module);
// Return the full path for |module|.
- string GetModulePath(const CodeModule *module);
+ string GetModulePath(const CodeModule* module);
// Return the path to the symbol file for |module|. If an empty string is
// returned, then |module| doesn't have a symbol file.
- string GetModuleSymbolFile(const CodeModule *module);
+ string GetModuleSymbolFile(const CodeModule* module);
// Generate the breakpad symbol file for |module|. Return true if successful.
// File is generated in /tmp.
- bool GenerateSymbolFile(const CodeModule *module,
- const SystemInfo *system_info);
+ bool GenerateSymbolFile(const CodeModule* module,
+ const SystemInfo* system_info);
};
} // namespace google_breakpad
diff --git a/src/tools/mac/crash_report/on_demand_symbol_supplier.mm b/src/tools/mac/crash_report/on_demand_symbol_supplier.mm
index 1955d26..cfcecee 100644
--- a/src/tools/mac/crash_report/on_demand_symbol_supplier.mm
+++ b/src/tools/mac/crash_report/on_demand_symbol_supplier.mm
@@ -51,10 +51,10 @@
using google_breakpad::SymbolSupplier;
using google_breakpad::SystemInfo;
-OnDemandSymbolSupplier::OnDemandSymbolSupplier(const string &search_dir,
- const string &symbol_search_dir)
+OnDemandSymbolSupplier::OnDemandSymbolSupplier(const string& search_dir,
+ const string& symbol_search_dir)
: search_dir_(search_dir) {
- NSFileManager *mgr = [NSFileManager defaultManager];
+ NSFileManager* mgr = [NSFileManager defaultManager];
size_t length = symbol_search_dir.length();
if (length) {
// Load all sym files in symbol_search_dir into our module_file_map
@@ -62,51 +62,51 @@
// MODULE mac x86 BBF0A8F9BEADDD2048E6464001CA193F0 GoogleDesktopDaemon
// or
// MODULE mac ppc BBF0A8F9BEADDD2048E6464001CA193F0 GoogleDesktopDaemon
- const char *symbolSearchStr = symbol_search_dir.c_str();
- NSString *symbolSearchPath =
+ const char* symbolSearchStr = symbol_search_dir.c_str();
+ NSString* symbolSearchPath =
[mgr stringWithFileSystemRepresentation:symbolSearchStr
length:strlen(symbolSearchStr)];
- NSDirectoryEnumerator *dirEnum = [mgr enumeratorAtPath:symbolSearchPath];
- NSString *fileName;
- NSCharacterSet *hexSet =
+ NSDirectoryEnumerator* dirEnum = [mgr enumeratorAtPath:symbolSearchPath];
+ NSString* fileName;
+ NSCharacterSet* hexSet =
[NSCharacterSet characterSetWithCharactersInString:@"0123456789ABCDEF"];
- NSCharacterSet *newlineSet =
+ NSCharacterSet* newlineSet =
[NSCharacterSet characterSetWithCharactersInString:@"\r\n"];
while ((fileName = [dirEnum nextObject])) {
// Check to see what type of file we have
- NSDictionary *attrib = [dirEnum fileAttributes];
- NSString *fileType = [attrib objectForKey:NSFileType];
+ NSDictionary* attrib = [dirEnum fileAttributes];
+ NSString* fileType = [attrib objectForKey:NSFileType];
if ([fileType isEqualToString:NSFileTypeDirectory]) {
// Skip subdirectories
[dirEnum skipDescendents];
} else {
- NSString *filePath = [symbolSearchPath stringByAppendingPathComponent:fileName];
- NSString *dataStr = [NSString stringWithContentsOfFile:filePath encoding:NSUTF8StringEncoding error:NULL];
+ NSString* filePath = [symbolSearchPath stringByAppendingPathComponent:fileName];
+ NSString* dataStr = [NSString stringWithContentsOfFile:filePath encoding:NSUTF8StringEncoding error:NULL];
if (dataStr) {
// Check file to see if it is of appropriate type, and grab module
// name.
- NSScanner *scanner = [NSScanner scannerWithString:dataStr];
+ NSScanner* scanner = [NSScanner scannerWithString:dataStr];
BOOL goodScan = [scanner scanString:@"MODULE mac " intoString:nil];
if (goodScan) {
goodScan = ([scanner scanString:@"x86 " intoString:nil] ||
[scanner scanString:@"x86_64 " intoString:nil] ||
[scanner scanString:@"ppc " intoString:nil]);
if (goodScan) {
- NSString *moduleID;
+ NSString* moduleID;
goodScan = [scanner scanCharactersFromSet:hexSet
intoString:&moduleID];
if (goodScan) {
// Module IDs are always 33 chars long
goodScan = [moduleID length] == 33;
if (goodScan) {
- NSString *moduleName;
+ NSString* moduleName;
goodScan = [scanner scanUpToCharactersFromSet:newlineSet
intoString:&moduleName];
if (goodScan) {
goodScan = [moduleName length] > 0;
if (goodScan) {
- const char *moduleNameStr = [moduleName UTF8String];
- const char *filePathStr = [filePath fileSystemRepresentation];
+ const char* moduleNameStr = [moduleName UTF8String];
+ const char* filePathStr = [filePath fileSystemRepresentation];
// Map our file
module_file_map_[moduleNameStr] = filePathStr;
}
@@ -122,9 +122,9 @@
}
SymbolSupplier::SymbolResult
-OnDemandSymbolSupplier::GetSymbolFile(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file) {
+OnDemandSymbolSupplier::GetSymbolFile(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file) {
string path(GetModuleSymbolFile(module));
if (path.empty()) {
@@ -142,10 +142,10 @@
}
SymbolSupplier::SymbolResult
-OnDemandSymbolSupplier::GetSymbolFile(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file,
- string *symbol_data) {
+OnDemandSymbolSupplier::GetSymbolFile(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file,
+ string* symbol_data) {
SymbolSupplier::SymbolResult s = GetSymbolFile(module,
system_info,
symbol_file);
@@ -162,11 +162,11 @@
}
SymbolSupplier::SymbolResult
-OnDemandSymbolSupplier::GetCStringSymbolData(const CodeModule *module,
- const SystemInfo *system_info,
- string *symbol_file,
- char **symbol_data,
- size_t *symbol_data_size) {
+OnDemandSymbolSupplier::GetCStringSymbolData(const CodeModule* module,
+ const SystemInfo* system_info,
+ string* symbol_file,
+ char** symbol_data,
+ size_t* symbol_data_size) {
std::string symbol_data_string;
SymbolSupplier::SymbolResult result = GetSymbolFile(module,
system_info,
@@ -186,21 +186,21 @@
return result;
}
-void OnDemandSymbolSupplier::FreeSymbolData(const CodeModule *module) {
- map<string, char *>::iterator it = memory_buffers_.find(module->code_file());
+void OnDemandSymbolSupplier::FreeSymbolData(const CodeModule* module) {
+ map<string, char*>::iterator it = memory_buffers_.find(module->code_file());
if (it != memory_buffers_.end()) {
delete [] it->second;
memory_buffers_.erase(it);
}
}
-string OnDemandSymbolSupplier::GetLocalModulePath(const CodeModule *module) {
- NSFileManager *mgr = [NSFileManager defaultManager];
- const char *moduleStr = module->code_file().c_str();
- NSString *modulePath =
+string OnDemandSymbolSupplier::GetLocalModulePath(const CodeModule* module) {
+ NSFileManager* mgr = [NSFileManager defaultManager];
+ const char* moduleStr = module->code_file().c_str();
+ NSString* modulePath =
[mgr stringWithFileSystemRepresentation:moduleStr length:strlen(moduleStr)];
- const char *searchStr = search_dir_.c_str();
- NSString *searchDir =
+ const char* searchStr = search_dir_.c_str();
+ NSString* searchDir =
[mgr stringWithFileSystemRepresentation:searchStr length:strlen(searchStr)];
if ([mgr fileExistsAtPath:modulePath])
@@ -209,9 +209,9 @@
// If the module is not found, try to start appending the components to the
// search string and stop if a file (not dir) is found or all components
// have been appended
- NSArray *pathComponents = [modulePath componentsSeparatedByString:@"/"];
+ NSArray* pathComponents = [modulePath componentsSeparatedByString:@"/"];
size_t count = [pathComponents count];
- NSMutableString *path = [NSMutableString string];
+ NSMutableString* path = [NSMutableString string];
for (size_t i = 0; i < count; ++i) {
[path setString:searchDir];
@@ -230,22 +230,22 @@
return "";
}
-string OnDemandSymbolSupplier::GetModulePath(const CodeModule *module) {
+string OnDemandSymbolSupplier::GetModulePath(const CodeModule* module) {
return module->code_file();
}
-string OnDemandSymbolSupplier::GetNameForModule(const CodeModule *module) {
+string OnDemandSymbolSupplier::GetNameForModule(const CodeModule* module) {
return PathnameStripper::File(module->code_file());
}
-string OnDemandSymbolSupplier::GetModuleSymbolFile(const CodeModule *module) {
+string OnDemandSymbolSupplier::GetModuleSymbolFile(const CodeModule* module) {
string name(GetNameForModule(module));
map<string, string>::iterator result = module_file_map_.find(name);
return (result == module_file_map_.end()) ? "" : (*result).second;
}
-static float GetFileModificationTime(const char *path) {
+static float GetFileModificationTime(const char* path) {
float result = 0;
struct stat file_stat;
if (stat(path, &file_stat) == 0)
@@ -255,12 +255,12 @@
return result;
}
-bool OnDemandSymbolSupplier::GenerateSymbolFile(const CodeModule *module,
- const SystemInfo *system_info) {
+bool OnDemandSymbolSupplier::GenerateSymbolFile(const CodeModule* module,
+ const SystemInfo* system_info) {
bool result = true;
string name = GetNameForModule(module);
string module_path = GetLocalModulePath(module);
- NSString *symbol_path = [NSString stringWithFormat:@"/tmp/%s.%s.sym",
+ NSString* symbol_path = [NSString stringWithFormat:@"/tmp/%s.%s.sym",
name.c_str(), system_info->cpu.c_str()];
if (module_path.empty())
diff --git a/src/tools/mac/dump_syms/dump_syms_tool.cc b/src/tools/mac/dump_syms/dump_syms_tool.cc
index 6f68457..8d73f0b 100644
--- a/src/tools/mac/dump_syms/dump_syms_tool.cc
+++ b/src/tools/mac/dump_syms/dump_syms_tool.cc
@@ -106,7 +106,7 @@
}
}
-static bool Start(const Options &options) {
+static bool Start(const Options& options) {
SymbolData symbol_data = options.cfi ? ALL_SYMBOL_DATA : NO_CFI;
DumpSymbols dump_symbols(symbol_data, options.handle_inter_cu_refs);
@@ -210,7 +210,7 @@
extern int optind;
signed char ch;
- while ((ch = getopt(argc, (char * const *)argv, "ia:g:chr?")) != -1) {
+ while ((ch = getopt(argc, (char * const*)argv, "ia:g:chr?")) != -1) {
switch (ch) {
case 'i':
options->header_only = true;
diff --git a/src/tools/mac/dump_syms/macho_dump.cc b/src/tools/mac/dump_syms/macho_dump.cc
index 6e784ca..34f82ab 100644
--- a/src/tools/mac/dump_syms/macho_dump.cc
+++ b/src/tools/mac/dump_syms/macho_dump.cc
@@ -60,7 +60,7 @@
string program_name;
-int check_syscall(int result, const char *operation, const char *filename) {
+int check_syscall(int result, const char* operation, const char* filename) {
if (result < 0) {
fprintf(stderr, "%s: %s '%s': %s\n",
program_name.c_str(), operation,
@@ -73,7 +73,7 @@
class DumpSection: public mach_o::Reader::SectionHandler {
public:
DumpSection() : index_(0) { }
- bool HandleSection(const mach_o::Section §ion) {
+ bool HandleSection(const mach_o::Section& section) {
printf(" section %d '%s' in segment '%s'\n"
" address: 0x%llx\n"
" alignment: 1 << %d B\n"
@@ -92,13 +92,13 @@
class DumpCommand: public mach_o::Reader::LoadCommandHandler {
public:
- DumpCommand(mach_o::Reader *reader) : reader_(reader), index_(0) { }
+ DumpCommand(mach_o::Reader* reader) : reader_(reader), index_(0) { }
bool UnknownCommand(mach_o::LoadCommandType type,
- const ByteBuffer &contents) {
+ const ByteBuffer& contents) {
printf(" load command %d: %d", index_++, type);
return true;
}
- bool SegmentCommand(const mach_o::Segment &segment) {
+ bool SegmentCommand(const mach_o::Segment& segment) {
printf(" load command %d: %s-bit segment '%s'\n"
" address: 0x%llx\n"
" memory size: 0x%llx\n"
@@ -115,24 +115,24 @@
return reader_->WalkSegmentSections(segment, &dump_section);
}
private:
- mach_o::Reader *reader_;
+ mach_o::Reader* reader_;
int index_;
};
-void DumpFile(const char *filename) {
+void DumpFile(const char* filename) {
int fd = check_syscall(open(filename, O_RDONLY), "opening", filename);
struct stat attributes;
check_syscall(fstat(fd, &attributes),
"getting file attributes for", filename);
- void *mapping = mmap(NULL, attributes.st_size, PROT_READ,
+ void* mapping = mmap(NULL, attributes.st_size, PROT_READ,
MAP_PRIVATE, fd, 0);
close(fd);
- check_syscall(mapping == (void *)-1 ? -1 : 0,
+ check_syscall(mapping == (void*)-1 ? -1 : 0,
"mapping contents of", filename);
mach_o::FatReader::Reporter fat_reporter(filename);
mach_o::FatReader fat_reader(&fat_reporter);
- if (!fat_reader.Read(reinterpret_cast<uint8_t *>(mapping),
+ if (!fat_reader.Read(reinterpret_cast<uint8_t*>(mapping),
attributes.st_size)) {
exit(1);
}
@@ -140,14 +140,14 @@
size_t object_files_size;
const SuperFatArch* super_fat_object_files =
fat_reader.object_files(&object_files_size);
- struct fat_arch *object_files;
+ struct fat_arch* object_files;
if (!super_fat_object_files->ConvertToFatArch(object_files)) {
exit(1);
}
printf(" object file count: %ld\n", object_files_size);
for (size_t i = 0; i < object_files_size; i++) {
- const struct fat_arch &file = object_files[i];
- const NXArchInfo *fat_arch_info =
+ const struct fat_arch& file = object_files[i];
+ const NXArchInfo* fat_arch_info =
google_breakpad::BreakpadGetArchInfoFromCpuType(
file.cputype, file.cpusubtype);
printf("\n object file %ld:\n"
@@ -162,7 +162,7 @@
name << filename;
if (object_files_size > 1)
name << ", object file #" << i;
- ByteBuffer file_contents(reinterpret_cast<uint8_t *>(mapping)
+ ByteBuffer file_contents(reinterpret_cast<uint8_t*>(mapping)
+ file.offset, file.size);
mach_o::Reader::Reporter reporter(name.str());
mach_o::Reader reader(&reporter);
@@ -170,7 +170,7 @@
exit(1);
}
- const NXArchInfo *macho_arch_info =
+ const NXArchInfo* macho_arch_info =
NXGetArchInfoFromCpuType(reader.cpu_type(),
reader.cpu_subtype());
printf(" Mach-O header:\n"
@@ -190,7 +190,7 @@
} // namespace
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
program_name = google_breakpad::BaseName(argv[0]);
if (argc == 1) {
fprintf(stderr, "Usage: %s FILE ...\n"
diff --git a/src/tools/solaris/dump_syms/dump_syms.cc b/src/tools/solaris/dump_syms/dump_syms.cc
index 54cea57..ba396e1 100644
--- a/src/tools/solaris/dump_syms/dump_syms.cc
+++ b/src/tools/solaris/dump_syms/dump_syms.cc
@@ -36,13 +36,13 @@
using namespace google_breakpad;
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
if (argc != 2) {
fprintf(stderr, "Usage: %s <binary-with-stab-symbol>\n", argv[0]);
return 1;
}
- const char *binary = argv[1];
+ const char* binary = argv[1];
DumpSymbols dumper;
if (!dumper.WriteSymbolFile(binary, fileno(stdout))) {
diff --git a/src/tools/solaris/dump_syms/testdata/dump_syms_regtest.cc b/src/tools/solaris/dump_syms/testdata/dump_syms_regtest.cc
index e617a23..6824ed9 100644
--- a/src/tools/solaris/dump_syms/testdata/dump_syms_regtest.cc
+++ b/src/tools/solaris/dump_syms/testdata/dump_syms_regtest.cc
@@ -41,7 +41,7 @@
void f() { member_ = g(); }
virtual int g() { return 2; }
- static char* h(const C &that) { return 0; }
+ static char* h(const C& that) { return 0; }
private:
int member_;
@@ -53,12 +53,12 @@
} // namespace google_breakpad
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
google_breakpad::C object;
object.set_member(google_breakpad::i());
object.f();
int value = object.g();
- char *nothing = object.h(object);
+ char* nothing = object.h(object);
return 0;
}
diff --git a/src/tools/windows/converter/ms_symbol_server_converter.cc b/src/tools/windows/converter/ms_symbol_server_converter.cc
index 2b40fae..102d06f 100644
--- a/src/tools/windows/converter/ms_symbol_server_converter.cc
+++ b/src/tools/windows/converter/ms_symbol_server_converter.cc
@@ -92,7 +92,7 @@
#endif // _MSC_VER >= 1400
bool GUIDOrSignatureIdentifier::InitializeFromString(
- const string &identifier) {
+ const string& identifier) {
type_ = TYPE_NONE;
size_t length = identifier.length();
@@ -128,7 +128,7 @@
#undef SSCANF
MSSymbolServerConverter::MSSymbolServerConverter(
- const string &local_cache, const vector<string> &symbol_servers)
+ const string& local_cache, const vector<string>& symbol_servers)
: symbol_path_(),
fail_dns_(false),
fail_timeout_(false),
@@ -184,7 +184,7 @@
}
}
- bool Initialize(HANDLE process, char *path, bool invade_process) {
+ bool Initialize(HANDLE process, char* path, bool invade_process) {
process_ = process;
// TODO(nbilling): Figure out why dbghelp.dll is being loaded from
@@ -240,7 +240,7 @@
// are supported by calling Delete().
class AutoDeleter {
public:
- explicit AutoDeleter(const string &path) : path_(path) {}
+ explicit AutoDeleter(const string& path) : path_(path) {}
~AutoDeleter() {
int error;
@@ -270,10 +270,10 @@
};
MSSymbolServerConverter::LocateResult
-MSSymbolServerConverter::LocateFile(const string &debug_or_code_file,
- const string &debug_or_code_id,
- const string &version,
- string *file_name) {
+MSSymbolServerConverter::LocateFile(const string& debug_or_code_file,
+ const string& debug_or_code_id,
+ const string& version,
+ string* file_name) {
assert(file_name);
file_name->clear();
@@ -290,7 +290,7 @@
HANDLE process = GetCurrentProcess(); // CloseHandle is not needed.
AutoSymSrv symsrv;
if (!symsrv.Initialize(process,
- const_cast<char *>(symbol_path_.c_str()),
+ const_cast<char*>(symbol_path_.c_str()),
false)) {
fprintf(stderr, "LocateFile: SymInitialize: error %lu for %s %s %s\n",
GetLastError(),
@@ -326,8 +326,8 @@
char path[MAX_PATH];
if (!SymFindFileInPath(
process, NULL,
- const_cast<char *>(debug_or_code_file.c_str()),
- const_cast<void *>(identifier.guid_or_signature_pointer()),
+ const_cast<char*>(debug_or_code_file.c_str()),
+ const_cast<void*>(identifier.guid_or_signature_pointer()),
identifier.age(), 0,
identifier.type() == GUIDOrSignatureIdentifier::TYPE_GUID ?
SSRVOPT_GUIDPTR : SSRVOPT_DWORDPTR,
@@ -393,15 +393,15 @@
MSSymbolServerConverter::LocateResult
-MSSymbolServerConverter::LocatePEFile(const MissingSymbolInfo &missing,
- string *pe_file) {
+MSSymbolServerConverter::LocatePEFile(const MissingSymbolInfo& missing,
+ string* pe_file) {
return LocateFile(missing.code_file, missing.code_identifier,
missing.version, pe_file);
}
MSSymbolServerConverter::LocateResult
-MSSymbolServerConverter::LocateSymbolFile(const MissingSymbolInfo &missing,
- string *symbol_file) {
+MSSymbolServerConverter::LocateSymbolFile(const MissingSymbolInfo& missing,
+ string* symbol_file) {
return LocateFile(missing.debug_file, missing.debug_identifier,
missing.version, symbol_file);
}
@@ -412,13 +412,13 @@
ULONG action,
ULONG64 data,
ULONG64 context) {
- MSSymbolServerConverter *self =
- reinterpret_cast<MSSymbolServerConverter *>(context);
+ MSSymbolServerConverter* self =
+ reinterpret_cast<MSSymbolServerConverter*>(context);
switch (action) {
case CBA_EVENT: {
- IMAGEHLP_CBA_EVENT *cba_event =
- reinterpret_cast<IMAGEHLP_CBA_EVENT *>(data);
+ IMAGEHLP_CBA_EVENT* cba_event =
+ reinterpret_cast<IMAGEHLP_CBA_EVENT*>(data);
// Put the string into a string object to be able to use string::find
// for substring matching. This is important because the not-found
@@ -429,8 +429,8 @@
// desc_action maps strings (in desc) to boolean pointers that are to
// be set to true if the string matches.
struct desc_action {
- const char *desc; // The substring to match.
- bool *action; // On match, this pointer will be set to true.
+ const char* desc; // The substring to match.
+ bool* action; // On match, this pointer will be set to true.
};
static const desc_action desc_actions[] = {
@@ -478,7 +478,7 @@
// static
BOOL CALLBACK MSSymbolServerConverter::SymFindFileInPathCallback(
- const char *filename, void *context) {
+ const char* filename, void* context) {
// FALSE ends the search, indicating that the located symbol file is
// satisfactory.
return FALSE;
@@ -486,12 +486,12 @@
MSSymbolServerConverter::LocateResult
MSSymbolServerConverter::LocateAndConvertSymbolFile(
- const MissingSymbolInfo &missing,
+ const MissingSymbolInfo& missing,
bool keep_symbol_file,
bool keep_pe_file,
- string *converted_symbol_file,
- string *symbol_file,
- string *out_pe_file) {
+ string* converted_symbol_file,
+ string* symbol_file,
+ string* out_pe_file) {
assert(converted_symbol_file);
converted_symbol_file->clear();
if (symbol_file) {
@@ -580,7 +580,7 @@
*converted_symbol_file = pdb_file.substr(0, pdb_file.length() - 4) + ".sym";
- FILE *converted_output = NULL;
+ FILE* converted_output = NULL;
#if _MSC_VER >= 1400 // MSVC 2005/8
errno_t err;
if ((err = fopen_s(&converted_output, converted_symbol_file->c_str(), "w"))
@@ -634,10 +634,10 @@
MSSymbolServerConverter::LocateResult
MSSymbolServerConverter::LocateAndConvertPEFile(
- const MissingSymbolInfo &missing,
+ const MissingSymbolInfo& missing,
bool keep_pe_file,
- string *converted_symbol_file,
- string *out_pe_file) {
+ string* converted_symbol_file,
+ string* out_pe_file) {
assert(converted_symbol_file);
converted_symbol_file->clear();
@@ -676,7 +676,7 @@
*converted_symbol_file = pe_file.substr(0, pe_file.length() - 4) + ".sym";
- FILE *converted_output = NULL;
+ FILE* converted_output = NULL;
#if _MSC_VER >= 1400 // MSVC 2005/8
errno_t err;
if ((err = fopen_s(&converted_output, converted_symbol_file->c_str(), "w"))
diff --git a/src/tools/windows/converter/ms_symbol_server_converter.h b/src/tools/windows/converter/ms_symbol_server_converter.h
index 401f7c3..40d65d5 100644
--- a/src/tools/windows/converter/ms_symbol_server_converter.h
+++ b/src/tools/windows/converter/ms_symbol_server_converter.h
@@ -101,13 +101,13 @@
// component fields: either a GUID and age, or signature and age. If
// successful, sets the relevant fields in the object, including the type
// field, and returns true. On error, returns false.
- bool InitializeFromString(const string &identifier);
+ bool InitializeFromString(const string& identifier);
GUIDOrSignatureType type() const { return type_; }
GUID guid() const { return guid_; }
DWORD signature() const { return signature_; }
int age() const { return age_; }
- const void *guid_or_signature_pointer() const { return &guid_; }
+ const void* guid_or_signature_pointer() const { return &guid_; }
private:
GUIDOrSignatureType type_;
@@ -141,23 +141,23 @@
// store to try. The vector must contain at least one string. None of the
// strings passed to this constructor may contain asterisk ('*') or semicolon
// (';') characters, as the symbol engine uses these characters as separators.
- MSSymbolServerConverter(const string &local_cache,
- const vector<string> &symbol_servers);
+ MSSymbolServerConverter(const string& local_cache,
+ const vector<string>& symbol_servers);
// Locates the PE file (DLL or EXE) specified by the identifying information
// in |missing|, by checking the symbol stores identified when the object
// was created. When returning LOCATE_SUCCESS, pe_file is set to
// the pathname of the decompressed PE file as it is stored in the
// local cache.
- LocateResult LocatePEFile(const MissingSymbolInfo &missing, string *pe_file);
+ LocateResult LocatePEFile(const MissingSymbolInfo& missing, string* pe_file);
// Locates the symbol file specified by the identifying information in
// |missing|, by checking the symbol stores identified when the object
// was created. When returning LOCATE_SUCCESS, symbol_file is set to
// the pathname of the decompressed symbol file as it is stored in the
// local cache.
- LocateResult LocateSymbolFile(const MissingSymbolInfo &missing,
- string *symbol_file);
+ LocateResult LocateSymbolFile(const MissingSymbolInfo& missing,
+ string* symbol_file);
// Calls LocateSymbolFile and converts the returned symbol file to the
// dumped-symbol format, storing it adjacent to the symbol file. The
@@ -170,12 +170,12 @@
// is desired, set |keep_symbol_file| and |keep_pe_file| to false to indicate
// that the original symbol file (pdb) and executable file (exe, dll) should
// be deleted after conversion.
- LocateResult LocateAndConvertSymbolFile(const MissingSymbolInfo &missing,
+ LocateResult LocateAndConvertSymbolFile(const MissingSymbolInfo& missing,
bool keep_symbol_file,
bool keep_pe_file,
- string *converted_symbol_file,
- string *symbol_file,
- string *pe_file);
+ string* converted_symbol_file,
+ string* symbol_file,
+ string* pe_file);
// Calls LocatePEFile and converts the returned PE file to the
// dumped-symbol format, storing it adjacent to the PE file. The
@@ -188,10 +188,10 @@
// to false to indicate that the executable file (exe, dll) should be deleted
// after conversion.
// NOTE: Currrently only supports x64 PEs.
- LocateResult LocateAndConvertPEFile(const MissingSymbolInfo &missing,
- bool keep_pe_file,
- string *converted_symbol_file,
- string *pe_file);
+ LocateResult LocateAndConvertPEFile(const MissingSymbolInfo& missing,
+ bool keep_pe_file,
+ string* converted_symbol_file,
+ string* pe_file);
private:
// Locates the PDB or PE file (DLL or EXE) specified by the identifying
@@ -199,9 +199,9 @@
// the symbol stores identified when the object was created. When
// returning LOCATE_SUCCESS, file_name is set to the pathname of the
// decompressed PDB or PE file file as it is stored in the local cache.
- LocateResult LocateFile(const string &debug_or_code_file,
- const string &debug_or_code_id,
- const string &version, string *file_name);
+ LocateResult LocateFile(const string& debug_or_code_file,
+ const string& debug_or_code_id,
+ const string& version, string* file_name);
// Called by various SymSrv functions to report status as progress is made
// and to allow the callback to influence processing. Messages sent to this
@@ -215,8 +215,8 @@
// SymFindFileInPath actually seems to accept NULL for a callback function
// and behave properly for our needs in that case, but the documentation
// doesn't mention it, so this little callback is provided.
- static BOOL CALLBACK SymFindFileInPathCallback(const char *filename,
- void *context);
+ static BOOL CALLBACK SymFindFileInPathCallback(const char* filename,
+ void* context);
// The search path used by SymSrv, built based on the arguments to the
// constructor.
diff --git a/src/tools/windows/converter_exe/converter.cc b/src/tools/windows/converter_exe/converter.cc
index 5b70903..06bd8eb 100644
--- a/src/tools/windows/converter_exe/converter.cc
+++ b/src/tools/windows/converter_exe/converter.cc
@@ -62,14 +62,14 @@
using google_breakpad::MSSymbolServerConverter;
using google_breakpad::WindowsStringUtils;
-const char *kMissingStringDelimiters = "|";
-const char *kLocalCachePath = "c:\\symbols";
-const char *kNoExeMSSSServer = "http://msdl.microsoft.com/download/symbols/";
+const char* kMissingStringDelimiters = "|";
+const char* kLocalCachePath = "c:\\symbols";
+const char* kNoExeMSSSServer = "http://msdl.microsoft.com/download/symbols/";
// Windows stdio doesn't do line buffering. Use this function to flush after
// writing to stdout and stderr so that a log will be available if the
// converter crashes.
-static int FprintfFlush(FILE *file, const char *format, ...) {
+static int FprintfFlush(FILE* file, const char* format, ...) {
va_list arguments;
va_start(arguments, format);
int retval = vfprintf(file, format, arguments);
@@ -86,11 +86,11 @@
// localtime_s is safer but is only available in MSVC8. Use localtime
// in earlier environments.
- struct tm *time_pointer;
+ struct tm* time_pointer;
#if _MSC_VER >= 1400 // MSVC 2005/8
struct tm time_struct;
- time_pointer = &time_struct;
- if (localtime_s(time_pointer, ¤t_time) != 0) {
+ time_pointer =& time_struct;
+ if (localtime_s(time_pointer,& current_time) != 0) {
return kUnknownDateAndTime;
}
#else // _MSC_VER >= 1400
@@ -111,12 +111,12 @@
// ParseMissingString turns |missing_string| into a MissingSymbolInfo
// structure. It returns true on success, and false if no such conversion
// is possible.
-static bool ParseMissingString(const string &missing_string,
- MissingSymbolInfo *missing_info) {
+static bool ParseMissingString(const string& missing_string,
+ MissingSymbolInfo* missing_info) {
assert(missing_info);
vector<string> tokens;
- Tokenizer::Tokenize(kMissingStringDelimiters, missing_string, &tokens);
+ Tokenizer::Tokenize(kMissingStringDelimiters, missing_string,& tokens);
if (tokens.size() != 5) {
return false;
}
@@ -133,8 +133,8 @@
// StringMapToWStringMap takes each element in a map that associates
// (narrow) strings to strings and converts the keys and values to wstrings.
// Returns true on success and false on failure, printing an error message.
-static bool StringMapToWStringMap(const map<string, string> &smap,
- map<wstring, wstring> *wsmap) {
+static bool StringMapToWStringMap(const map<string, string>& smap,
+ map<wstring, wstring>* wsmap) {
assert(wsmap);
wsmap->clear();
@@ -142,7 +142,7 @@
iterator != smap.end();
++iterator) {
wstring key;
- if (!WindowsStringUtils::safe_mbstowcs(iterator->first, &key)) {
+ if (!WindowsStringUtils::safe_mbstowcs(iterator->first,& key)) {
FprintfFlush(stderr,
"StringMapToWStringMap: safe_mbstowcs failed for key %s\n",
iterator->first.c_str());
@@ -150,7 +150,7 @@
}
wstring value;
- if (!WindowsStringUtils::safe_mbstowcs(iterator->second, &value)) {
+ if (!WindowsStringUtils::safe_mbstowcs(iterator->second,& value)) {
FprintfFlush(stderr, "StringMapToWStringMap: safe_mbstowcs failed "
"for value %s\n",
iterator->second.c_str());
@@ -166,8 +166,8 @@
// MissingSymbolInfoToParameters turns a MissingSymbolInfo structure into a
// map of parameters suitable for passing to HTTPDownload or HTTPUpload.
// Returns true on success and false on failure, printing an error message.
-static bool MissingSymbolInfoToParameters(const MissingSymbolInfo &missing_info,
- map<wstring, wstring> *wparameters) {
+static bool MissingSymbolInfoToParameters(const MissingSymbolInfo& missing_info,
+ map<wstring, wstring>* wparameters) {
assert(wparameters);
map<string, string> parameters;
@@ -175,25 +175,25 @@
// Indicate the params are encoded.
parameters["encoded"] = "true"; // The string value here does not matter.
- WebSafeBase64Escape(missing_info.code_file, &encoded_param);
+ WebSafeBase64Escape(missing_info.code_file,& encoded_param);
parameters["code_file"] = encoded_param;
- WebSafeBase64Escape(missing_info.code_identifier, &encoded_param);
+ WebSafeBase64Escape(missing_info.code_identifier,& encoded_param);
parameters["code_identifier"] = encoded_param;
- WebSafeBase64Escape(missing_info.debug_file, &encoded_param);
+ WebSafeBase64Escape(missing_info.debug_file,& encoded_param);
parameters["debug_file"] = encoded_param;
- WebSafeBase64Escape(missing_info.debug_identifier, &encoded_param);
+ WebSafeBase64Escape(missing_info.debug_identifier,& encoded_param);
parameters["debug_identifier"] = encoded_param;
if (!missing_info.version.empty()) {
// The version is optional.
- WebSafeBase64Escape(missing_info.version, &encoded_param);
+ WebSafeBase64Escape(missing_info.version,& encoded_param);
parameters["version"] = encoded_param;
}
- WebSafeBase64Escape("WinSymConv", &encoded_param);
+ WebSafeBase64Escape("WinSymConv",& encoded_param);
parameters["product"] = encoded_param;
if (!StringMapToWStringMap(parameters, wparameters)) {
@@ -207,18 +207,18 @@
// UploadSymbolFile sends |converted_file| as identified by |missing_info|
// to the symbol server rooted at |upload_symbol_url|. Returns true on
// success and false on failure, printing an error message.
-static bool UploadSymbolFile(const wstring &upload_symbol_url,
- const MissingSymbolInfo &missing_info,
- const string &converted_file) {
+static bool UploadSymbolFile(const wstring& upload_symbol_url,
+ const MissingSymbolInfo& missing_info,
+ const string& converted_file) {
map<wstring, wstring> parameters;
- if (!MissingSymbolInfoToParameters(missing_info, ¶meters)) {
+ if (!MissingSymbolInfoToParameters(missing_info,& parameters)) {
// MissingSymbolInfoToParameters or a callee will have printed an error.
return false;
}
wstring converted_file_w;
- if (!WindowsStringUtils::safe_mbstowcs(converted_file, &converted_file_w)) {
+ if (!WindowsStringUtils::safe_mbstowcs(converted_file,& converted_file_w)) {
FprintfFlush(stderr, "UploadSymbolFile: safe_mbstowcs failed for %s\n",
converted_file.c_str());
return false;
@@ -245,18 +245,18 @@
// |fetch_symbol_failure_url| that the symbol file identified by
// |missing_info| could authoritatively not be located. Returns
// true on success and false on failure.
-static bool SendFetchFailedPing(const wstring &fetch_symbol_failure_url,
- const MissingSymbolInfo &missing_info) {
+static bool SendFetchFailedPing(const wstring& fetch_symbol_failure_url,
+ const MissingSymbolInfo& missing_info) {
map<wstring, wstring> parameters;
- if (!MissingSymbolInfoToParameters(missing_info, ¶meters)) {
+ if (!MissingSymbolInfoToParameters(missing_info,& parameters)) {
// MissingSymbolInfoToParameters or a callee will have printed an error.
return false;
}
string content;
if (!HTTPDownload::Download(fetch_symbol_failure_url,
- ¶meters,
- &content,
+ & parameters,
+ & content,
NULL)) {
FprintfFlush(stderr, "SendFetchFailedPing: HTTPDownload::Download failed "
"for %s %s %s\n",
@@ -275,7 +275,7 @@
// the given blacklist regular expression.
// The debug_file name is used from the MissingSymbolInfo struct,
// matched against the blacklist_regex.
-static bool SafeToMakeExternalRequest(const MissingSymbolInfo &missing_info,
+static bool SafeToMakeExternalRequest(const MissingSymbolInfo& missing_info,
std::regex blacklist_regex) {
string file_name = missing_info.debug_file;
// Use regex_search because we want to match substrings.
@@ -352,8 +352,8 @@
// stored at |options.local_cache_path|. Because nothing can be done even in
// the event of a failure, this function returns no value, although it
// may result in error messages being printed.
-static void ConvertMissingSymbolFile(const MissingSymbolInfo &missing_info,
- const ConverterOptions &options) {
+static void ConvertMissingSymbolFile(const MissingSymbolInfo& missing_info,
+ const ConverterOptions& options) {
string time_string = CurrentDateAndTime();
FprintfFlush(stdout, "converter: %s: attempting %s %s %s\n",
time_string.c_str(),
@@ -402,7 +402,7 @@
located = converter.LocateAndConvertSymbolFile(missing_info,
false, // keep_symbol_file
false, // keep_pe_file
- &converted_file,
+ & converted_file,
NULL, // symbol_file
NULL); // pe_file
switch (located) {
@@ -476,7 +476,7 @@
missing_info,
false, // keep_symbol_file
false, // keep_pe_file
- &converted_file,
+ & converted_file,
NULL, // symbol_file
NULL); // pe_file
} else {
@@ -561,9 +561,9 @@
// Reads the contents of file |file_name| and populates |contents|.
// Returns true on success.
-static bool ReadFile(string file_name, string *contents) {
+static bool ReadFile(string file_name, string* contents) {
char buffer[1024 * 8];
- FILE *fp = fopen(file_name.c_str(), "rt");
+ FILE* fp = fopen(file_name.c_str(), "rt");
if (!fp) {
return false;
}
@@ -578,7 +578,7 @@
// ConvertMissingSymbolsList obtains a missing symbol list from
// |options.missing_symbols_url| or |options.missing_symbols_file| and calls
// ConvertMissingSymbolFile for each missing symbol file in the list.
-static bool ConvertMissingSymbolsList(const ConverterOptions &options) {
+static bool ConvertMissingSymbolsList(const ConverterOptions& options) {
// Set param to indicate requesting for encoded response.
map<wstring, wstring> parameters;
parameters[L"product"] = L"WinSymConv";
@@ -586,17 +586,17 @@
// Get the missing symbol list.
string missing_symbol_list;
if (!options.missing_symbols_file.empty()) {
- if (!ReadFile(options.missing_symbols_file, &missing_symbol_list)) {
+ if (!ReadFile(options.missing_symbols_file,& missing_symbol_list)) {
return false;
}
- } else if (!HTTPDownload::Download(options.missing_symbols_url, ¶meters,
- &missing_symbol_list, NULL)) {
+ } else if (!HTTPDownload::Download(options.missing_symbols_url,& parameters,
+ & missing_symbol_list, NULL)) {
return false;
}
// Tokenize the content into a vector.
vector<string> missing_symbol_lines;
- Tokenizer::Tokenize("\n", missing_symbol_list, &missing_symbol_lines);
+ Tokenizer::Tokenize("\n", missing_symbol_list,& missing_symbol_lines);
FprintfFlush(stderr, "Found %d missing symbol files in list.\n",
missing_symbol_lines.size() - 1); // last line is empty.
@@ -605,14 +605,14 @@
iterator != missing_symbol_lines.end();
++iterator) {
// Decode symbol line.
- const string &encoded_line = *iterator;
+ const string& encoded_line = *iterator;
// Skip lines that are blank.
if (encoded_line.empty()) {
continue;
}
string line;
- if (!WebSafeBase64Unescape(encoded_line, &line)) {
+ if (!WebSafeBase64Unescape(encoded_line,& line)) {
// If decoding fails, assume the line is not encoded.
// This is helpful when the program connects to a debug server without
// encoding.
@@ -623,7 +623,7 @@
// Turn each element into a MissingSymbolInfo structure.
MissingSymbolInfo missing_info;
- if (!ParseMissingString(line, &missing_info)) {
+ if (!ParseMissingString(line,& missing_info)) {
FprintfFlush(stderr, "ConvertMissingSymbols: ParseMissingString failed "
"for %s from %ws\n",
line.c_str(), options.missing_symbols_url.c_str());
@@ -647,7 +647,7 @@
// usage prints the usage message. It returns 1 as a convenience, to be used
// as a return value from main.
-static int usage(const char *program_name) {
+static int usage(const char* program_name) {
FprintfFlush(stderr,
"usage: %s [options]\n"
" -f <full_msss_server> MS servers to ask for all symbols\n"
@@ -670,7 +670,7 @@
// "Internal" servers consist only of those whose names start with
// the literal string "\\filer\".
-static bool IsInternalServer(const string &server_name) {
+static bool IsInternalServer(const string& server_name) {
if (server_name.find("\\\\filer\\") == 0) {
return true;
}
@@ -679,9 +679,9 @@
// Adds a server with the given name to the list of internal or external
// servers, as appropriate.
-static void AddServer(const string &server_name,
- vector<string> *internal_servers,
- vector<string> *external_servers) {
+static void AddServer(const string& server_name,
+ vector<string>* internal_servers,
+ vector<string>* external_servers) {
if (IsInternalServer(server_name)) {
internal_servers->push_back(server_name);
} else {
@@ -691,7 +691,7 @@
} // namespace
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
string time_string = CurrentDateAndTime();
FprintfFlush(stdout, "converter: %s: starting\n", time_string.c_str());
@@ -710,12 +710,12 @@
string value = argv[argi + 1];
if (option == "-f") {
- AddServer(value, &options.full_internal_msss_servers,
- &options.full_external_msss_servers);
+ AddServer(value,& options.full_internal_msss_servers,
+ & options.full_external_msss_servers);
have_any_msss_servers = true;
} else if (option == "-n") {
- AddServer(value, &options.no_exe_internal_msss_servers,
- &options.no_exe_external_msss_servers);
+ AddServer(value,& options.no_exe_internal_msss_servers,
+ & options.no_exe_external_msss_servers);
have_any_msss_servers = true;
} else if (option == "-l") {
if (!options.local_cache_path.empty()) {
@@ -724,14 +724,14 @@
options.local_cache_path = value;
} else if (option == "-s") {
if (!WindowsStringUtils::safe_mbstowcs(value,
- &options.upload_symbols_url)) {
+ & options.upload_symbols_url)) {
FprintfFlush(stderr, "main: safe_mbstowcs failed for %s\n",
value.c_str());
return 1;
}
} else if (option == "-m") {
if (!WindowsStringUtils::safe_mbstowcs(value,
- &options.missing_symbols_url)) {
+ & options.missing_symbols_url)) {
FprintfFlush(stderr, "main: safe_mbstowcs failed for %s\n",
value.c_str());
return 1;
@@ -744,7 +744,7 @@
} else if (option == "-t") {
if (!WindowsStringUtils::safe_mbstowcs(
value,
- &options.fetch_symbol_failure_url)) {
+ & options.fetch_symbol_failure_url)) {
FprintfFlush(stderr, "main: safe_mbstowcs failed for %s\n",
value.c_str());
return 1;
@@ -768,8 +768,8 @@
// Set the defaults. If the user specified any MSSS servers, don't use
// any default.
if (!have_any_msss_servers) {
- AddServer(kNoExeMSSSServer, &options.no_exe_internal_msss_servers,
- &options.no_exe_external_msss_servers);
+ AddServer(kNoExeMSSSServer,& options.no_exe_internal_msss_servers,
+ & options.no_exe_external_msss_servers);
}
if (options.local_cache_path.empty()) {
diff --git a/src/tools/windows/converter_exe/http_download.cc b/src/tools/windows/converter_exe/http_download.cc
index 5afc1cc..58fcbb3 100644
--- a/src/tools/windows/converter_exe/http_download.cc
+++ b/src/tools/windows/converter_exe/http_download.cc
@@ -83,11 +83,11 @@
// CheckParameters ensures that the parameters in |parameters| are safe for
// use in an HTTP URL. Returns true if they are, false if unsafe characters
// are present.
-static bool CheckParameters(const map<wstring, wstring> *parameters) {
+static bool CheckParameters(const map<wstring, wstring>* parameters) {
for (map<wstring, wstring>::const_iterator iterator = parameters->begin();
iterator != parameters->end();
++iterator) {
- const wstring &key = iterator->first;
+ const wstring& key = iterator->first;
if (key.empty()) {
// Disallow empty parameter names.
return false;
@@ -99,7 +99,7 @@
}
}
- const wstring &value = iterator->second;
+ const wstring& value = iterator->second;
for (unsigned int i = 0; i < value.size(); ++i) {
wchar_t c = value[i];
if (c < 32 || c == '"' || c == '?' || c == '&' || c > 127) {
@@ -141,8 +141,8 @@
}
// static
-bool HTTPDownload::Download(const wstring &url,
- const map<wstring, wstring> *parameters,
+bool HTTPDownload::Download(const wstring& url,
+ const map<wstring, wstring>* parameters,
string *content, int *status_code) {
assert(content);
AutoPtr<HttpClient> http_client(CreateHttpClient(url.c_str()));
diff --git a/src/tools/windows/converter_exe/http_download.h b/src/tools/windows/converter_exe/http_download.h
index 2d705d5..cbae11b 100644
--- a/src/tools/windows/converter_exe/http_download.h
+++ b/src/tools/windows/converter_exe/http_download.h
@@ -50,8 +50,8 @@
// transaction occurs. If Download fails before a transaction can occur,
// |status_code| will be set to 0. Any failures will result in messages
// being printed to stderr.
- static bool Download(const wstring &url,
- const map<wstring, wstring> *parameters,
+ static bool Download(const wstring& url,
+ const map<wstring, wstring>* parameters,
string *content, int *status_code);
private:
static HttpClient* CreateHttpClient(const wchar_t*);
diff --git a/src/tools/windows/converter_exe/tokenizer.cc b/src/tools/windows/converter_exe/tokenizer.cc
index 992694c..aee3986 100644
--- a/src/tools/windows/converter_exe/tokenizer.cc
+++ b/src/tools/windows/converter_exe/tokenizer.cc
@@ -33,8 +33,8 @@
namespace crash {
// static
-void Tokenizer::Tokenize(const string &delimiters, const string &input,
- vector<string> *output) {
+void Tokenizer::Tokenize(const string& delimiters, const string& input,
+ vector<string>* output) {
assert(output);
output->clear();
diff --git a/src/tools/windows/converter_exe/tokenizer.h b/src/tools/windows/converter_exe/tokenizer.h
index f4bbcfd..bfdfa22 100644
--- a/src/tools/windows/converter_exe/tokenizer.h
+++ b/src/tools/windows/converter_exe/tokenizer.h
@@ -42,8 +42,8 @@
// Splits |input| into a series of tokens delimited in the input string by
// any of the characters in |delimiters|. The tokens are passed back in the
// |output| vector.
- static void Tokenize(const string &delimiters, const string &input,
- vector<string> *output);
+ static void Tokenize(const string& delimiters, const string& input,
+ vector<string>* output);
};
} // namespace crash
diff --git a/src/tools/windows/converter_exe/winhttp_client.cc b/src/tools/windows/converter_exe/winhttp_client.cc
index 8a8ade3..cc70e53 100644
--- a/src/tools/windows/converter_exe/winhttp_client.cc
+++ b/src/tools/windows/converter_exe/winhttp_client.cc
@@ -197,7 +197,7 @@
if (!::WinHttpQueryHeaders(ToHINTERNET(request_handle),
WINHTTP_QUERY_STATUS_CODE,
WINHTTP_HEADER_NAME_BY_INDEX,
- static_cast<void *>(&http_status_string),
+ static_cast<void*>(&http_status_string),
&http_status_string_size, 0)) {
return false;
}
@@ -216,7 +216,7 @@
if (!::WinHttpQueryHeaders(ToHINTERNET(request_handle),
WINHTTP_QUERY_CONTENT_LENGTH,
WINHTTP_HEADER_NAME_BY_INDEX,
- static_cast<void *>(&content_length_string),
+ static_cast<void*>(&content_length_string),
&content_length_string_size, 0)) {
*content_length = kUnknownContentLength;
} else {
diff --git a/src/tools/windows/converter_exe/wininet_client.cc b/src/tools/windows/converter_exe/wininet_client.cc
index 3e542db..986a66f 100644
--- a/src/tools/windows/converter_exe/wininet_client.cc
+++ b/src/tools/windows/converter_exe/wininet_client.cc
@@ -196,7 +196,7 @@
DWORD http_status_string_size = sizeof(http_status_string);
if (!::HttpQueryInfo(ToHINTERNET(request_handle),
HTTP_QUERY_STATUS_CODE,
- static_cast<void *>(&http_status_string),
+ static_cast<void*>(&http_status_string),
&http_status_string_size,
0)) {
return false;
@@ -215,7 +215,7 @@
DWORD content_length_string_size = sizeof(content_length_string);
if (!::HttpQueryInfo(ToHINTERNET(request_handle),
HTTP_QUERY_CONTENT_LENGTH,
- static_cast<void *>(&content_length_string),
+ static_cast<void*>(&content_length_string),
&content_length_string_size,
0)) {
*content_length = kUnknownContentLength;
diff --git a/src/tools/windows/dump_syms/dump_syms.cc b/src/tools/windows/dump_syms/dump_syms.cc
index 5b7d177..1b1797d 100644
--- a/src/tools/windows/dump_syms/dump_syms.cc
+++ b/src/tools/windows/dump_syms/dump_syms.cc
@@ -43,7 +43,7 @@
using google_breakpad::PESourceLineWriter;
using std::unique_ptr;
-int wmain(int argc, wchar_t **argv) {
+int wmain(int argc, wchar_t** argv) {
bool success;
if (argc == 2) {
PDBSourceLineWriter pdb_writer;
diff --git a/src/tools/windows/dump_syms/dump_syms_unittest.cc b/src/tools/windows/dump_syms/dump_syms_unittest.cc
index 766e5c0..494b779 100644
--- a/src/tools/windows/dump_syms/dump_syms_unittest.cc
+++ b/src/tools/windows/dump_syms/dump_syms_unittest.cc
@@ -166,7 +166,7 @@
}
}
-class DumpSymsRegressionTest : public testing::TestWithParam<const wchar_t *> {
+class DumpSymsRegressionTest : public testing::TestWithParam<const wchar_t*> {
public:
virtual void SetUp() {
std::wstring self_dir;
@@ -181,7 +181,7 @@
std::wstring testdata_dir;
};
-class DumpSymsPEOnlyRegressionTest : public testing::TestWithParam<const wchar_t *> {
+class DumpSymsPEOnlyRegressionTest : public testing::TestWithParam<const wchar_t*> {
public:
virtual void SetUp() {
std::wstring self_dir;
diff --git a/src/tools/windows/dump_syms/testdata/dump_syms_regtest.cc b/src/tools/windows/dump_syms/testdata/dump_syms_regtest.cc
index e8efbeb..de6109f 100644
--- a/src/tools/windows/dump_syms/testdata/dump_syms_regtest.cc
+++ b/src/tools/windows/dump_syms/testdata/dump_syms_regtest.cc
@@ -48,7 +48,7 @@
void f() { member_ = g(); }
virtual int g() { return 2; }
- static char* h(const C &that) { return 0; }
+ static char* h(const C& that) { return 0; }
private:
int member_;
@@ -60,12 +60,12 @@
} // namespace google_breakpad
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
google_breakpad::C object;
object.set_member(google_breakpad::i());
object.f();
int value = object.g();
- char *nothing = object.h(object);
+ char* nothing = object.h(object);
return 0;
}
diff --git a/src/tools/windows/symupload/symupload.cc b/src/tools/windows/symupload/symupload.cc
index 7e30293..e6fa126 100644
--- a/src/tools/windows/symupload/symupload.cc
+++ b/src/tools/windows/symupload/symupload.cc
@@ -73,7 +73,7 @@
// Extracts the file version information for the given filename,
// as a string, for example, "1.2.3.4". Returns true on success.
-static bool GetFileVersionString(const wchar_t *filename, wstring *version) {
+static bool GetFileVersionString(const wchar_t* filename, wstring* version) {
DWORD handle;
DWORD version_size = GetFileVersionInfoSize(filename, &handle);
if (version_size < sizeof(VS_FIXEDFILEINFO)) {
@@ -85,7 +85,7 @@
return false;
}
- void *file_info_buffer = NULL;
+ void* file_info_buffer = NULL;
unsigned int file_info_length;
if (!VerQueryValue(&version_info[0], L"\\",
&file_info_buffer, &file_info_length)) {
@@ -95,7 +95,7 @@
// The maximum value of each version component is 65535 (0xffff),
// so the max length is 24, including the terminating null.
wchar_t ver_string[24];
- VS_FIXEDFILEINFO *file_info =
+ VS_FIXEDFILEINFO* file_info =
reinterpret_cast<VS_FIXEDFILEINFO*>(file_info_buffer);
swprintf(ver_string, sizeof(ver_string) / sizeof(ver_string[0]),
L"%d.%d.%d.%d",
@@ -114,9 +114,9 @@
// Creates a new temporary file and writes the symbol data from the given
// exe/dll file to it. Returns the path to the temp file in temp_file_path
// and information about the pdb in pdb_info.
-static bool DumpSymbolsToTempFile(const wchar_t *file,
- wstring *temp_file_path,
- PDBModuleInfo *pdb_info) {
+static bool DumpSymbolsToTempFile(const wchar_t* file,
+ wstring* temp_file_path,
+ PDBModuleInfo* pdb_info) {
google_breakpad::PDBSourceLineWriter writer;
// Use EXE_FILE to get information out of the exe/dll in addition to the
// pdb. The name and version number of the exe/dll are of value, and
@@ -135,7 +135,7 @@
return false;
}
- FILE *temp_file = NULL;
+ FILE* temp_file = NULL;
#if _MSC_VER >= 1400 // MSVC 2005/8
if (_wfopen_s(&temp_file, temp_filename, L"w") != 0)
#else // _MSC_VER >= 1400
@@ -270,9 +270,9 @@
exit(0);
}
-int wmain(int argc, wchar_t *argv[]) {
- const wchar_t *module;
- const wchar_t *product = nullptr;
+int wmain(int argc, wchar_t* argv[]) {
+ const wchar_t* module;
+ const wchar_t* product = nullptr;
int timeout = -1;
int currentarg = 1;
bool use_sym_upload_v2 = false;
