diff --git a/include/zipr_dollop_man.h b/include/zipr_dollop_man.h
index f563716d1d0e74eef7779e9a84bb70d6040fb27a..a8b0387daedddc5bf189c037697ba90f4d23a830 100644
--- a/include/zipr_dollop_man.h
+++ b/include/zipr_dollop_man.h
@@ -36,8 +36,8 @@
class ZiprDollopManager_t {
public:
ZiprDollopManager_t() {}
- void AddDollop(Dollop_t *dollop);
- Zipr_SDK::Dollop_t *AddNewDollop(libIRDB::Instruction_t *start);
+ void AddDollops(Dollop_t *dollop_head);
+ Zipr_SDK::Dollop_t *AddNewDollops(libIRDB::Instruction_t *start);
Zipr_SDK::Dollop_t *GetContainingDollop(libIRDB::Instruction_t *insn);
size_t Size() {
return m_dollops.size();
@@ -64,6 +64,7 @@ class ZiprDollopManager_t {
}
friend std::ostream &operator<<(std::ostream &out, const ZiprDollopManager_t &dollop_man);
private:
+ void AddDollop(Dollop_t *dollop);
std::list<Dollop_t*> m_dollops;
std::map<libIRDB::Instruction_t*,Dollop_t*> m_insn_to_dollop;
std::list<DollopPatch_t*> m_patches;
diff --git a/src/dollop.cpp b/src/dollop.cpp
index 0395f83fcf0f943c63f27024fefce363ea76e678..35ec13b89d5022e947e37bb818720be22a86fb20 100644
--- a/src/dollop.cpp
+++ b/src/dollop.cpp
@@ -17,7 +17,12 @@ namespace Zipr_SDK {
loop = start;
do {
push_back(new DollopEntry_t(loop));
- } while (NULL != (loop = loop->GetFallthrough()));
+ } while ((NULL != (loop = loop->GetFallthrough())) &&
+ /*
+ * If this is a pinned instruction, we want to stop!
+ */
+ (NULL == loop->GetIndirectBranchTargetAddress())
+ );
m_size = CalculateWorstCaseSize();
}
diff --git a/src/zipr.cpp b/src/zipr.cpp
index 4c4e4b27c46bcef5d46cfb437d48143608ffbbdb..eaca0c5f682cb5d37ef766f7d2385cdbd613e30c 100644
--- a/src/zipr.cpp
+++ b/src/zipr.cpp
@@ -1402,7 +1402,9 @@ void ZiprImpl_t::PlaceDollops()
);
last_de_fits = (std::next(dit,1)==dit_end) /* last */ &&
(placement.GetEnd()>=(cur_addr+ /* fits */
- _DetermineWorstCaseInsnSize(dollop_entry->Instruction(), false))
+ _DetermineWorstCaseInsnSize(dollop_entry->Instruction(),
+ to_place->Fallthrough() != NULL))
+ /* with or without fallthrough */
);
if (de_and_fallthrough_fit || last_de_fits)
@@ -1430,7 +1432,7 @@ void ZiprImpl_t::PlaceDollops()
* Split the dollop where we stopped being able to place it.
*/
Dollop_t *split_dollop = to_place->Split((*dit)->Instruction());
- m_dollop_mgr.AddDollop(split_dollop);
+ m_dollop_mgr.AddDollops(split_dollop);
if (m_verbose)
cout << "Split a dollop because it didn't fit. Fallthrough to "
@@ -1498,7 +1500,8 @@ void ZiprImpl_t::CreateDollops()
{
UnresolvedPinned_t up=(*it).first;
- m_dollop_mgr.AddNewDollop(up.GetInstruction());
+ Instruction_t *start_insn = up.GetInstruction();
+ m_dollop_mgr.AddNewDollops(start_insn);
}
m_dollop_mgr.UpdateAllTargets();
if (m_verbose)
@@ -1686,6 +1689,9 @@ void ZiprImpl_t::UpdatePins()
if (m_verbose)
cout << "Patching pin at " << std::hex << patch_addr << " to "
<< std::hex << target_addr << ": " << d.CompleteInstr << endl;
+ assert(target_dollop_entry_instruction != NULL &&
+ target_dollop_entry_instruction == uu.GetInstruction());
+
PatchJump(patch_addr, target_addr);
diff --git a/src/zipr_dollop_man.cpp b/src/zipr_dollop_man.cpp
index 51abb32105073c9ed5006a60ba18c7959d141b3e..cba38edae2d44c3f5dc81e39713a44d4709958d7 100644
--- a/src/zipr_dollop_man.cpp
+++ b/src/zipr_dollop_man.cpp
@@ -8,7 +8,7 @@ using namespace libIRDB;
namespace zipr {
- Dollop_t *ZiprDollopManager_t::AddNewDollop(Instruction_t *start) {
+ Dollop_t *ZiprDollopManager_t::AddNewDollops(Instruction_t *start) {
Dollop_t *new_dollop = NULL;
Dollop_t *existing_dollop = GetContainingDollop(start);
@@ -32,7 +32,7 @@ namespace zipr {
/*
* Split at this dollop to make a new one!
*/
- AddDollop(new_dollop = existing_dollop->Split(start));
+ AddDollops(new_dollop = existing_dollop->Split(start));
return new_dollop;
}
}
@@ -40,9 +40,31 @@ namespace zipr {
/*
* There is no target dollop. Let's create one!
*/
- new_dollop = Dollop_t::CreateNewDollop(start);
- AddDollop(new_dollop);
- return new_dollop;
+ Dollop_t *original_new_dollop = NULL, *previous_dollop = NULL;
+ Instruction_t *fallthrough = NULL;
+ original_new_dollop = new_dollop = Dollop_t::CreateNewDollop(start);
+
+ while (fallthrough = new_dollop->back()->Instruction()->GetFallthrough())
+ {
+ /*
+ * Look FIRST for a containing dollop.
+ */
+ Dollop_t *existing_dollop = GetContainingDollop(fallthrough);
+ if (existing_dollop)
+ {
+ new_dollop->Fallthrough(existing_dollop);
+ break;
+ }
+ /*
+ * Otherwise, create a new dollop from the fallthrough
+ * and link them together.
+ */
+ previous_dollop = new_dollop;
+ new_dollop = Dollop_t::CreateNewDollop(fallthrough);
+ previous_dollop->Fallthrough(new_dollop);
+ }
+ AddDollops(original_new_dollop);
+ return original_new_dollop;
}
}
@@ -65,6 +87,15 @@ namespace zipr {
return NULL;
}
+ void ZiprDollopManager_t::AddDollops(Dollop_t *dollop_head) {
+ Dollop_t *dollop = dollop_head;
+ while (dollop != NULL)
+ {
+ AddDollop(dollop);
+ dollop = dollop->Fallthrough();
+ }
+ }
+
void ZiprDollopManager_t::AddDollop(Dollop_t *dollop) {
/*
* Populate/update the instruction-to-dollop map.
@@ -94,7 +125,7 @@ namespace zipr {
it++;
if (entry->Instruction() &&
entry->Instruction()->GetTarget()) {
- Dollop_t *new_target=AddNewDollop(entry->Instruction()->GetTarget());
+ Dollop_t *new_target=AddNewDollops(entry->Instruction()->GetTarget());
/*
* In the case there is a change, we have to restart.
diff --git a/test/ZiprDollop.cpp b/test/ZiprDollop.cpp
index bab53c37c7d71238d9899b9e95df70fedeb1fff9..98164d59cdeb185e121c60ebec9f8e843c45e1d5 100644
--- a/test/ZiprDollop.cpp
+++ b/test/ZiprDollop.cpp
@@ -46,7 +46,7 @@ bool TestGetContainingDollopNoFallthrough() {
Dollop_t *dollop_a = NULL;
dollop_a = Dollop_t::CreateNewDollop(insn_a);
- dollop_man.AddDollop(dollop_a);
+ dollop_man.AddDollops(dollop_a);
return dollop_man.GetContainingDollop(insn_b) == NULL &&
dollop_man.GetContainingDollop(insn_a) == dollop_a;
@@ -61,7 +61,7 @@ bool TestGetContainingDollopFallthrough(void) {
insn_a->SetFallthrough(insn_b);
dollop_a = Dollop_t::CreateNewDollop(insn_a);
- dollop_man.AddDollop(dollop_a);
+ dollop_man.AddDollops(dollop_a);
return dollop_man.GetContainingDollop(insn_b) == dollop_a &&
dollop_man.GetContainingDollop(insn_a) == dollop_a;
@@ -73,8 +73,8 @@ bool TestGetContainingDollop(void) {
libIRDB::Instruction_t *insn_b = new libIRDB::Instruction_t();
Dollop_t *dollop_a = Dollop_t::CreateNewDollop(insn_a);
Dollop_t *dollop_b = Dollop_t::CreateNewDollop(insn_b);
- dollop_man.AddDollop(dollop_a);
- dollop_man.AddDollop(dollop_b);
+ dollop_man.AddDollops(dollop_a);
+ dollop_man.AddDollops(dollop_b);
return dollop_man.GetContainingDollop(insn_a) == dollop_a &&
dollop_man.GetContainingDollop(insn_b) == dollop_b;
}
@@ -82,7 +82,7 @@ bool TestGetContainingDollop(void) {
bool TestAddDollopEntry(void) {
ZiprDollopManager_t dollop_man;
libIRDB::Instruction_t *insn = new libIRDB::Instruction_t();
- dollop_man.AddDollop(Dollop_t::CreateNewDollop(insn));
+ dollop_man.AddDollops(Dollop_t::CreateNewDollop(insn));
return 1 == dollop_man.Size();
}
@@ -142,16 +142,16 @@ bool TestAddNewDollopSplitsExistingDollop(void) {
insn_c->SetFallthrough(insn_d);
a = Dollop_t::CreateNewDollop(insn_a);
- dollop_man.AddDollop(a);
+ dollop_man.AddDollops(a);
success = (a->GetDollopEntryCount() == 4) && dollop_man.Size() == 1;
- cout << "Before AddNewDollop()." << endl;
+ cout << "Before AddNewDollops()." << endl;
cout << dollop_man << endl;
- b = dollop_man.AddNewDollop(insn_c);
+ b = dollop_man.AddNewDollops(insn_c);
- cout << "After AddNewDollop()." << endl;
+ cout << "After AddNewDollops()." << endl;
cout << dollop_man << endl;
return success &&
a->GetDollopEntryCount() == 2 &&
@@ -193,8 +193,8 @@ bool TestUpdateTargetsDollopManager(void) {
cout << "&a: " << std::hex << a << endl;
cout << "&c: " << std::hex << c << endl;
- dollop_man.AddDollop(a);
- dollop_man.AddDollop(c);
+ dollop_man.AddDollops(a);
+ dollop_man.AddDollops(c);
original_insn_d_container = dollop_man.GetContainingDollop(insn_d);
@@ -247,8 +247,8 @@ bool TestDollopPatchMapDollopManager(void) {
patch_aa.Target(dollop_a);
patch_c.Target(dollop_c);
- dollop_man.AddDollop(dollop_a);
- dollop_man.AddDollop(dollop_c);
+ dollop_man.AddDollops(dollop_a);
+ dollop_man.AddDollops(dollop_c);
dollop_man.AddDollopPatch(&patch_a);
dollop_man.AddDollopPatch(&patch_aa);