Load -> Apply because this language is a shit show

emesare · emesare · commit ebff89f5f1d4 · 2025-03-31T01:56:45.000-04:00
Windows def'd somethings and now i either have to spam undef everywhere, use a namespace, or do this...
diff --git a/view/sharedcache/api/python/sharedcache.py b/view/sharedcache/api/python/sharedcache.py
@@ -109,15 +109,15 @@ class SharedCacheController:
     def __init__(self, view: BinaryView):
         self.handle = sccore.BNGetSharedCacheController(view.handle)
 
-    def load_region(self, view: BinaryView, region: CacheRegion) -> bool:
+    def apply_region(self, view: BinaryView, region: CacheRegion) -> bool:
         api_region: sccore.BNSharedCacheRegion = region_to_api(region)
-        result = sccore.BNSharedCacheControllerLoadRegion(self.handle, view.handle, api_region)
+        result = sccore.BNSharedCacheControllerApplyRegion(self.handle, view.handle, api_region)
         sccore.BNSharedCacheFreeRegion(api_region)
         return result
 
-    def load_image(self, view: BinaryView, image: CacheImage) -> bool:
+    def apply_image(self, view: BinaryView, image: CacheImage) -> bool:
         api_image: sccore.BNSharedCacheImage = image_to_api(image)
-        result = sccore.BNSharedCacheControllerLoadImage(self.handle, view.handle, api_image)
+        result = sccore.BNSharedCacheControllerApplyImage(self.handle, view.handle, api_image)
         sccore.BNSharedCacheFreeImage(api_image)
         return result
 
diff --git a/view/sharedcache/api/sharedcache.cpp b/view/sharedcache/api/sharedcache.cpp
@@ -121,18 +121,18 @@ DSCRef<SharedCacheController> SharedCacheController::GetController(BinaryView& v
     return new SharedCacheController(controller);
 }
 
-bool SharedCacheController::LoadRegion(BinaryView &view, const CacheRegion &region)
+bool SharedCacheController::ApplyRegion(BinaryView &view, const CacheRegion &region)
 {
 	auto apiRegion = RegionToApi(region);
-    bool result = BNSharedCacheControllerLoadRegion(m_object, view.GetObject(), &apiRegion);
+    bool result = BNSharedCacheControllerApplyRegion(m_object, view.GetObject(), &apiRegion);
 	BNSharedCacheFreeRegion(apiRegion);
 	return result;
 }
 
-bool SharedCacheController::LoadImage(BinaryView &view, const CacheImage &image)
+bool SharedCacheController::ApplyImage(BinaryView &view, const CacheImage &image)
 {
 	auto apiImage = ImageToApi(image);
-	bool result = BNSharedCacheControllerLoadImage(m_object, view.GetObject(), &apiImage);
+	bool result = BNSharedCacheControllerApplyImage(m_object, view.GetObject(), &apiImage);
 	BNSharedCacheFreeImage(apiImage);
 	return result;
 }
diff --git a/view/sharedcache/api/sharedcacheapi.h b/view/sharedcache/api/sharedcacheapi.h
@@ -292,13 +292,13 @@ namespace SharedCacheAPI {
 		explicit SharedCacheController(BNSharedCacheController* controller);
 		static DSCRef<SharedCacheController> GetController(BinaryNinja::BinaryView& view);
 
-		bool LoadRegion(BinaryNinja::BinaryView& view, const CacheRegion& region);
+		bool ApplyRegion(BinaryNinja::BinaryView& view, const CacheRegion& region);
 
 		// Attempt to load the given image into the view.
 		//
 		// It is the callers responsibility to run linear sweep and update analysis, as you might want to add
 		// multiple images at a time.
-		bool LoadImage(BinaryNinja::BinaryView& view, const CacheImage& image);
+		bool ApplyImage(BinaryNinja::BinaryView& view, const CacheImage& image);
 
 		bool IsRegionLoaded(const CacheRegion& region) const;
 		bool IsImageLoaded(const CacheImage& image) const;
diff --git a/view/sharedcache/api/sharedcachecore.h b/view/sharedcache/api/sharedcachecore.h
@@ -113,8 +113,8 @@ extern "C"
 	SHAREDCACHE_FFI_API BNSharedCacheController* BNNewSharedCacheControllerReference(BNSharedCacheController* controller);
 	SHAREDCACHE_FFI_API void BNFreeSharedCacheControllerReference(BNSharedCacheController* controller);
 
-	SHAREDCACHE_FFI_API bool BNSharedCacheControllerLoadImage(BNSharedCacheController* controller, BNBinaryView* view, BNSharedCacheImage* image);
-	SHAREDCACHE_FFI_API bool BNSharedCacheControllerLoadRegion(BNSharedCacheController* controller, BNBinaryView* view, BNSharedCacheRegion* region);
+	SHAREDCACHE_FFI_API bool BNSharedCacheControllerApplyImage(BNSharedCacheController* controller, BNBinaryView* view, BNSharedCacheImage* image);
+	SHAREDCACHE_FFI_API bool BNSharedCacheControllerApplyRegion(BNSharedCacheController* controller, BNBinaryView* view, BNSharedCacheRegion* region);
 
 	SHAREDCACHE_FFI_API bool BNSharedCacheControllerIsImageLoaded(BNSharedCacheController* controller, BNSharedCacheImage* image);
 	SHAREDCACHE_FFI_API bool BNSharedCacheControllerIsRegionLoaded(BNSharedCacheController* controller, BNSharedCacheRegion* region);
diff --git a/view/sharedcache/core/SharedCacheController.cpp b/view/sharedcache/core/SharedCacheController.cpp
@@ -84,18 +84,15 @@ DSCRef<SharedCacheController> SharedCacheController::FromView(BinaryView& view)
     return dscView->second;
 }
 
-bool SharedCacheController::LoadRegionAtAddress(BinaryView& view, const uint64_t address)
+bool SharedCacheController::ApplyRegionAtAddress(BinaryView& view, const uint64_t address)
 {
     auto region = m_cache.GetRegionAt(address);
     if (!region)
         return false;
-
-    LogInfo("Loading region at %llx named %s with range %llx - %llx", address, region->name.c_str(), region->start, region->start + region->size);
-
-    return LoadRegion(view, *region);
+    return ApplyRegion(view, *region);
 }
 
-bool SharedCacheController::LoadRegion(BinaryView& view, const CacheRegion& region)
+bool SharedCacheController::ApplyRegion(BinaryView& view, const CacheRegion& region)
 {
     // TODO: Check m_loadedRegions? This seems redundant...
     // Loads the given region into the BinaryView and marks it as loaded.
@@ -146,14 +143,13 @@ bool SharedCacheController::IsRegionLoaded(const CacheRegion &region) const
         });
 }
 
-bool SharedCacheController::LoadImage(BinaryView& view, const CacheImage& image)
+bool SharedCacheController::ApplyImage(BinaryView& view, const CacheImage& image)
 {
     // TODO: Check m_loadedImages? This seems redundant...
-    // TODO: Will this load the header for the image as well?
     // Load all regions of an image and mark the image as loaded.
     bool loadedRegion = false;
     for (const auto& regionStart : image.regionStarts)
-        if (LoadRegionAtAddress(view, regionStart))
+        if (ApplyRegionAtAddress(view, regionStart))
             loadedRegion = true;
 
     // If there was no loaded regions than we just want to forgo loading the image.
diff --git a/view/sharedcache/core/SharedCacheController.h b/view/sharedcache/core/SharedCacheController.h
@@ -35,13 +35,13 @@ namespace BinaryNinja::DSC {
 
         // TODO: LoadResult type? AlreadyLoaded, Loaded, NotLoaded.
         // NOTE: `address` should be the start of a region, not containing the address.
-        bool LoadRegionAtAddress(BinaryView& view, uint64_t address);
-        bool LoadRegion(BinaryView& view, const CacheRegion& region);
+        bool ApplyRegionAtAddress(BinaryView& view, uint64_t address);
+        bool ApplyRegion(BinaryView& view, const CacheRegion& region);
         bool IsRegionLoaded(const CacheRegion& region) const;
 
         // Loads the relevant image info into the view. This does not update analysis so if you
         // call this make sure at some point you update analysis and likely with linear sweep.
-        bool LoadImage(BinaryView& view, const CacheImage& image);
+        bool ApplyImage(BinaryView& view, const CacheImage& image);
         bool IsImageLoaded(const CacheImage& image) const;
 
         // Get the metadata for saving the state of the shared cache.
diff --git a/view/sharedcache/core/SharedCacheView.cpp b/view/sharedcache/core/SharedCacheView.cpp
@@ -789,7 +789,7 @@ bool SharedCacheView::Init()
 	auto autoLoadPattern = std::regex(".*libsystem_c.dylib");
 	for (const auto& [_, image] : sharedCache.GetImages())
 		if (std::regex_match(image.GetName(), autoLoadPattern))
-			cacheController->LoadImage(*this, image);
+			cacheController->ApplyImage(*this, image);
 
 	return true;
 }
diff --git a/view/sharedcache/core/ffi.cpp b/view/sharedcache/core/ffi.cpp
@@ -161,20 +161,20 @@ extern "C" {
 		DSC_API_OBJECT_FREE(controller);
 	}
 
-	bool BNSharedCacheControllerLoadImage(BNSharedCacheController* controller, BNBinaryView* data, BNSharedCacheImage* image)
+	bool BNSharedCacheControllerApplyImage(BNSharedCacheController* controller, BNBinaryView* data, BNSharedCacheImage* image)
 	{
 		Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));
 		// LoadImage will use the header, lets do everyone a favor and use the existing image!
 		if (const auto realImage = controller->object->GetCache().GetImageAt(image->headerAddress))
-			return controller->object->LoadImage(*view, *realImage);
+			return controller->object->ApplyImage(*view, *realImage);
 		// They gave us an unknown image, we will not have header information.
-		return controller->object->LoadImage(*view, ImageFromApi(*image));
+		return controller->object->ApplyImage(*view, ImageFromApi(*image));
 	}
 
-	bool BNSharedCacheControllerLoadRegion(BNSharedCacheController* controller, BNBinaryView* data, BNSharedCacheRegion* region)
+	bool BNSharedCacheControllerApplyRegion(BNSharedCacheController* controller, BNBinaryView* data, BNSharedCacheRegion* region)
 	{
 		Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));
-		return controller->object->LoadRegion(*view, RegionFromApi(*region));
+		return controller->object->ApplyRegion(*view, RegionFromApi(*region));
 	}
 
 	bool BNSharedCacheControllerIsRegionLoaded(BNSharedCacheController* controller, BNSharedCacheRegion* region)
diff --git a/view/sharedcache/ui/SharedCacheUINotifications.cpp b/view/sharedcache/ui/SharedCacheUINotifications.cpp
@@ -46,7 +46,7 @@ void UINotifications::OnViewChange(UIContext* context, ViewFrame* frame, const Q
 		if (auto foundRegion = controller->GetRegionContaining(addr))
 		{
 			// If we did not load the region, then we don't need to run analysis.
-			if (!controller->LoadRegion(view, *foundRegion))
+			if (!controller->ApplyRegion(view, *foundRegion))
 				return;
 			view.AddAnalysisOption("linearsweep");
 			view.UpdateAnalysis();
@@ -60,7 +60,7 @@ void UINotifications::OnViewChange(UIContext* context, ViewFrame* frame, const Q
 		if (auto foundImage = controller->GetImageContaining(addr))
 		{
 			// If we did not load the image, then we don't need to run analysis.
-			if (!controller->LoadImage(view, *foundImage))
+			if (!controller->ApplyImage(view, *foundImage))
 				return;
 			view.AddAnalysisOption("linearsweep");
 			view.UpdateAnalysis();
diff --git a/view/sharedcache/ui/dscpicker.cpp b/view/sharedcache/ui/dscpicker.cpp
@@ -45,7 +45,7 @@ void DisplayDSCPicker(UIContext* ctx, Ref<BinaryView> dscView)
 		{
 			if (const auto selectedImage = controller->GetImageWithName( selectedImageName))
 			{
-				controller->LoadImage(*dscView, *selectedImage);
+				controller->ApplyImage(*dscView, *selectedImage);
 				dscView->AddAnalysisOption("linearsweep");
 				dscView->UpdateAnalysis();
 			}
diff --git a/view/sharedcache/ui/dsctriage.cpp b/view/sharedcache/ui/dsctriage.cpp
@@ -83,7 +83,7 @@ DSCTriageView::DSCTriageView(QWidget* parent, BinaryViewRef data) : QWidget(pare
 					break;
 				std::string newLoad = fmt::format("Loading images... ({}/{})", loadedImages++, images.size());
 				imageLoadTask.SetProgressText(newLoad);
-				if (controller->LoadImage(*this->m_data, image))
+				if (controller->ApplyImage(*this->m_data, image))
 					setImageLoaded(image.headerAddress);
 			}
 			imageLoadTask.Finish();
diff --git a/view/sharedcache/workflow/SharedCacheWorkflow.cpp b/view/sharedcache/workflow/SharedCacheWorkflow.cpp
@@ -103,11 +103,11 @@ void FixupStubs(Ref<AnalysisContext> ctx)
 	static auto loadTarget = [](BinaryView& view, SharedCacheController& controller, uint64_t target) {
 		auto image = controller.GetImageContaining(target);
 		if (image.has_value())
-			return controller.LoadImage(view, *image);
+			return controller.ApplyImage(view, *image);
 
 		auto region = controller.GetRegionContaining(target);
 		if (region.has_value())
-			return controller.LoadRegion(view, *region);
+			return controller.ApplyRegion(view, *region);
 
 		return false;
 	};
@@ -205,7 +205,7 @@ void FixupStubs(Ref<AnalysisContext> ctx)
 		// Load stub region if not already loaded and reanalyze the function (to pickup stub functions)
 		if (workflowState->autoLoadStubsAndDyldData)
 			if (region->type == SharedCacheRegionTypeStubIsland)
-				if (controller->LoadRegion(*bv, *region))
+				if (controller->ApplyRegion(*bv, *region))
 					func->Reanalyze(); // TODO: Call mark updates required instead???
 
 		// Apply symbols to the relevant stub functions

Original file line number	Diff line number	Diff line change
`@@ -121,18 +121,18 @@ DSCRef<SharedCacheController> SharedCacheController::GetController(BinaryView& v`
`121`	`121`	`return new SharedCacheController(controller);`
`122`	`122`	`}`
`123`	`123`
`124`		`-bool SharedCacheController::LoadRegion(BinaryView &view, const CacheRegion &region)`
	`124`	`+bool SharedCacheController::ApplyRegion(BinaryView &view, const CacheRegion &region)`
`125`	`125`	`{`
`126`	`126`	`auto apiRegion = RegionToApi(region);`
`127`		`- bool result = BNSharedCacheControllerLoadRegion(m_object, view.GetObject(), &apiRegion);`
	`127`	`+ bool result = BNSharedCacheControllerApplyRegion(m_object, view.GetObject(), &apiRegion);`
`128`	`128`	`BNSharedCacheFreeRegion(apiRegion);`
`129`	`129`	`return result;`
`130`	`130`	`}`
`131`	`131`
`132`		`-bool SharedCacheController::LoadImage(BinaryView &view, const CacheImage &image)`
	`132`	`+bool SharedCacheController::ApplyImage(BinaryView &view, const CacheImage &image)`
`133`	`133`	`{`
`134`	`134`	`auto apiImage = ImageToApi(image);`
`135`		`- bool result = BNSharedCacheControllerLoadImage(m_object, view.GetObject(), &apiImage);`
	`135`	`+ bool result = BNSharedCacheControllerApplyImage(m_object, view.GetObject(), &apiImage);`
`136`	`136`	`BNSharedCacheFreeImage(apiImage);`
`137`	`137`	`return result;`
`138`	`138`	`}`
Original file line number	Diff line number	Diff line change
`@@ -84,18 +84,15 @@ DSCRef<SharedCacheController> SharedCacheController::FromView(BinaryView& view)`
`84`	`84`	`return dscView->second;`
`85`	`85`	`}`
`86`	`86`
`87`		`-bool SharedCacheController::LoadRegionAtAddress(BinaryView& view, const uint64_t address)`
	`87`	`+bool SharedCacheController::ApplyRegionAtAddress(BinaryView& view, const uint64_t address)`
`88`	`88`	`{`
`89`	`89`	`auto region = m_cache.GetRegionAt(address);`
`90`	`90`	`if (!region)`
`91`	`91`	`return false;`
`92`		`-`
`93`		`- LogInfo("Loading region at %llx named %s with range %llx - %llx", address, region->name.c_str(), region->start, region->start + region->size);`
`94`		`-`
`95`		`- return LoadRegion(view, *region);`
	`92`	`+ return ApplyRegion(view, *region);`
`96`	`93`	`}`
`97`	`94`
`98`		`-bool SharedCacheController::LoadRegion(BinaryView& view, const CacheRegion& region)`
	`95`	`+bool SharedCacheController::ApplyRegion(BinaryView& view, const CacheRegion& region)`
`99`	`96`	`{`
`100`	`97`	`// TODO: Check m_loadedRegions? This seems redundant...`
`101`	`98`	`// Loads the given region into the BinaryView and marks it as loaded.`
`@@ -146,14 +143,13 @@ bool SharedCacheController::IsRegionLoaded(const CacheRegion &region) const`
`146`	`143`	`});`
`147`	`144`	`}`
`148`	`145`
`149`		`-bool SharedCacheController::LoadImage(BinaryView& view, const CacheImage& image)`
	`146`	`+bool SharedCacheController::ApplyImage(BinaryView& view, const CacheImage& image)`
`150`	`147`	`{`
`151`	`148`	`// TODO: Check m_loadedImages? This seems redundant...`
`152`		`- // TODO: Will this load the header for the image as well?`
`153`	`149`	`// Load all regions of an image and mark the image as loaded.`
`154`	`150`	`bool loadedRegion = false;`
`155`	`151`	`for (const auto& regionStart : image.regionStarts)`
`156`		`- if (LoadRegionAtAddress(view, regionStart))`
	`152`	`+ if (ApplyRegionAtAddress(view, regionStart))`
`157`	`153`	`loadedRegion = true;`
`158`	`154`
`159`	`155`	`// If there was no loaded regions than we just want to forgo loading the image.`
Original file line number	Diff line number	Diff line change
`@@ -789,7 +789,7 @@ bool SharedCacheView::Init()`
`789`	`789`	`auto autoLoadPattern = std::regex(".*libsystem_c.dylib");`
`790`	`790`	`for (const auto& [_, image] : sharedCache.GetImages())`
`791`	`791`	`if (std::regex_match(image.GetName(), autoLoadPattern))`
`792`		`- cacheController->LoadImage(*this, image);`
	`792`	`+ cacheController->ApplyImage(*this, image);`
`793`	`793`
`794`	`794`	`return true;`
`795`	`795`	`}`
Original file line number	Diff line number	Diff line change
`@@ -161,20 +161,20 @@ extern "C" {`
`161`	`161`	`DSC_API_OBJECT_FREE(controller);`
`162`	`162`	`}`
`163`	`163`
`164`		`- bool BNSharedCacheControllerLoadImage(BNSharedCacheController* controller, BNBinaryView* data, BNSharedCacheImage* image)`
	`164`	`+ bool BNSharedCacheControllerApplyImage(BNSharedCacheController* controller, BNBinaryView* data, BNSharedCacheImage* image)`
`165`	`165`	`{`
`166`	`166`	`Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));`
`167`	`167`	`// LoadImage will use the header, lets do everyone a favor and use the existing image!`
`168`	`168`	`if (const auto realImage = controller->object->GetCache().GetImageAt(image->headerAddress))`
`169`		`- return controller->object->LoadImage(view, realImage);`
	`169`	`+ return controller->object->ApplyImage(view, realImage);`
`170`	`170`	`// They gave us an unknown image, we will not have header information.`
`171`		`- return controller->object->LoadImage(view, ImageFromApi(image));`
	`171`	`+ return controller->object->ApplyImage(view, ImageFromApi(image));`
`172`	`172`	`}`
`173`	`173`
`174`		`- bool BNSharedCacheControllerLoadRegion(BNSharedCacheController* controller, BNBinaryView* data, BNSharedCacheRegion* region)`
	`174`	`+ bool BNSharedCacheControllerApplyRegion(BNSharedCacheController* controller, BNBinaryView* data, BNSharedCacheRegion* region)`
`175`	`175`	`{`
`176`	`176`	`Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));`
`177`		`- return controller->object->LoadRegion(view, RegionFromApi(region));`
	`177`	`+ return controller->object->ApplyRegion(view, RegionFromApi(region));`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`bool BNSharedCacheControllerIsRegionLoaded(BNSharedCacheController* controller, BNSharedCacheRegion* region)`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ void DisplayDSCPicker(UIContext* ctx, Ref<BinaryView> dscView)`
`45`	`45`	`{`
`46`	`46`	`if (const auto selectedImage = controller->GetImageWithName( selectedImageName))`
`47`	`47`	`{`
`48`		`- controller->LoadImage(dscView, selectedImage);`
	`48`	`+ controller->ApplyImage(dscView, selectedImage);`
`49`	`49`	`dscView->AddAnalysisOption("linearsweep");`
`50`	`50`	`dscView->UpdateAnalysis();`
`51`	`51`	`}`