TEST(SplitRegionTest, Basic2)
{
//rectangular case
region_descriptor test3 = create_rectangle(cv::Rect(10,15, 10,20));
std::vector<region_descriptor> res3;
int ret3 = split_region(test3, 4, std::back_inserter(res3));
EXPECT_EQ(ret3, 4);
EXPECT_EQ(res3.size(), 4);
EXPECT_EQ(res3[0].size(), 50);
EXPECT_EQ(res3[1].size(), 50);
EXPECT_EQ(res3[2].size(), 50);
EXPECT_EQ(res3[3].size(), 50);
//to small case (one direction)
std::vector<region_descriptor> res4;
int ret4 = split_region(test3, 10, std::back_inserter(res4));
EXPECT_EQ(ret4, 2);
EXPECT_EQ(res4.size(), 2);
EXPECT_EQ(res4[0].size(), 100);
EXPECT_EQ(res4[1].size(), 100);
//irregular shaped case
region_descriptor test5 = test3;
test5.lineIntervals.push_back(region_interval(30,15,40));
test5.bounding_box.width = 25;
test5.bounding_box.height += 1;
std::vector<region_descriptor> res5;
int ret5 = split_region(test5, 5, std::back_inserter(res5));
EXPECT_EQ(ret5, 4);
EXPECT_EQ(res5.size(), 4);
}
void set_intersection(paramset const & other)
{
std::vector<region_t> res;
std::vector<region_t> new_sregions;
std::vector<region_t> const & oregions = other.regions();
for (std::size_t oregion_index = 0; oregion_index < oregions.size(); ++oregion_index)
{
new_sregions.clear();
region_t const & oregion = oregions[oregion_index];
for (std::size_t sregion_index = 0; sregion_index < m_regions.size(); ++sregion_index)
{
region_t & sregion = m_regions[sregion_index];
bool intersecting = true;
for (std::size_t i = 0; intersecting && i < oregion.box.size(); ++i)
{
if (oregion.box[i].second <= sregion.box[i].first || sregion.box[i].second <= oregion.box[i].first)
intersecting = false;
}
if (!intersecting)
{
new_sregions.push_back(std::move(sregion));
continue;
}
for (std::size_t i = 0; i < oregion.box.size(); ++i)
{
region_t removed;
boost::tie(sregion, removed) = split_region(std::move(sregion), i, oregion.box[i].first, true);
if (!removed.box.empty())
new_sregions.push_back(std::move(removed));
if (sregion.box.empty())
break;
boost::tie(sregion, removed) = split_region(std::move(sregion), i, oregion.box[i].second, false);
if (!removed.box.empty())
new_sregions.push_back(std::move(removed));
if (sregion.box.empty())
break;
}
if (!sregion.box.empty())
res.push_back(std::move(sregion));
}
m_regions = std::move(new_sregions);
}
m_regions = std::move(res);
}
bool set_union_impl(std::vector<region_t> oregions)
{
std::vector<region_t> new_oregions;
for (std::size_t sregion_index = 0; sregion_index < m_regions.size(); ++sregion_index)
{
region_t const & sregion = m_regions[sregion_index];
new_oregions.clear();
for (std::size_t oregion_index = 0; oregion_index < oregions.size(); ++oregion_index)
{
region_t & oregion = oregions[oregion_index];
BOOST_ASSERT(oregion.box.size() == sregion.box.size());
bool intersecting = true;
for (std::size_t i = 0; intersecting && i < oregion.box.size(); ++i)
{
if (oregion.box[i].second <= sregion.box[i].first || sregion.box[i].second <= oregion.box[i].first)
intersecting = false;
}
if (!intersecting)
{
new_oregions.push_back(std::move(oregion));
continue;
}
for (std::size_t i = 0; i < oregion.box.size(); ++i)
{
region_t removed;
boost::tie(oregion, removed) = split_region(std::move(oregion), i, sregion.box[i].first, true);
if (!removed.box.empty())
new_oregions.push_back(std::move(removed));
if (oregion.box.empty())
break;
boost::tie(oregion, removed) = split_region(std::move(oregion), i, sregion.box[i].second, false);
if (!removed.box.empty())
new_oregions.push_back(std::move(removed));
if (oregion.box.empty())
break;
}
}
oregions = std::move(new_oregions);
}
for (std::size_t i = 0; i < oregions.size(); ++i)
m_regions.push_back(std::move(oregions[i]));
return !oregions.empty();
}
TEST(SplitRegionTest, Basic)
{
//quadratic case
region_descriptor test = create_rectangle(cv::Rect(5,5,10,10));
std::vector<region_descriptor> res1;
int ret1 = split_region(test, 5, std::back_inserter(res1));
EXPECT_EQ(res1.size(), 4);
EXPECT_EQ(res1[0].size(), 25);
EXPECT_EQ(res1[1].size(), 25);
EXPECT_EQ(res1[2].size(), 25);
EXPECT_EQ(res1[3].size(), 25);
EXPECT_EQ(ret1, 4);
//too small case (both directions)
std::vector<region_descriptor> res2;
int ret2 = split_region(test, 6, std::back_inserter(res2));
EXPECT_EQ(ret2, 1);
EXPECT_EQ(res2.size(), 1);
EXPECT_EQ(res2[0].size(), 100);
}
UNICORN_EXPORT
uc_err uc_mem_unmap(struct uc_struct *uc, uint64_t address, size_t size)
{
MemoryRegion *mr;
uint64_t addr;
size_t count, len;
if (size == 0)
// nothing to unmap
return UC_ERR_OK;
// address must be aligned to uc->target_page_size
if ((address & uc->target_page_align) != 0)
return UC_ERR_ARG;
// size must be multiple of uc->target_page_size
if ((size & uc->target_page_align) != 0)
return UC_ERR_MAP;
if (uc->mem_redirect) {
address = uc->mem_redirect(address);
}
// check that user's entire requested block is mapped
if (!check_mem_area(uc, address, size))
return UC_ERR_NOMEM;
// Now we know entire region is mapped, so do the unmap
// We may need to split regions if this area spans adjacent regions
addr = address;
count = 0;
while(count < size) {
mr = memory_mapping(uc, addr);
len = MIN(size - count, mr->end - addr);
if (!split_region(uc, mr, addr, len, true))
return UC_ERR_NOMEM;
// if we can retrieve the mapping, then no splitting took place
// so unmap here
mr = memory_mapping(uc, addr);
if (mr != NULL)
uc->memory_unmap(uc, mr);
count += len;
addr += len;
}
return UC_ERR_OK;
}
UNICORN_EXPORT
uc_err uc_mem_protect(struct uc_struct *uc, uint64_t address, size_t size, uint32_t perms)
{
MemoryRegion *mr;
uint64_t addr = address;
size_t count, len;
if (size == 0)
// trivial case, no change
return UC_ERR_OK;
// address must be aligned to uc->target_page_size
if ((address & uc->target_page_align) != 0)
return UC_ERR_ARG;
// size must be multiple of uc->target_page_size
if ((size & uc->target_page_align) != 0)
return UC_ERR_ARG;
// check for only valid permissions
if ((perms & ~UC_PROT_ALL) != 0)
return UC_ERR_ARG;
// check that user's entire requested block is mapped
if (!check_mem_area(uc, address, size))
return UC_ERR_NOMEM;
// Now we know entire region is mapped, so change permissions
// We may need to split regions if this area spans adjacent regions
addr = address;
count = 0;
while(count < size) {
mr = memory_mapping(uc, addr);
len = MIN(size - count, mr->end - addr);
if (!split_region(uc, mr, addr, len, false))
return UC_ERR_NOMEM;
mr = memory_mapping(uc, addr);
mr->perms = perms;
uc->readonly_mem(mr, (perms & UC_PROT_WRITE) == 0);
count += len;
addr += len;
}
return UC_ERR_OK;
}
paramset remove_cut(std::size_t dim, value_type value, bool up)
{
paramset res;
region_t removed;
for (std::size_t i = m_regions.size(); i != 0; --i)
{
boost::tie(m_regions[i-1], removed) = split_region(std::move(m_regions[i-1]), dim, value, !up);
if (m_regions[i-1].box.empty())
{
std::swap(m_regions[i-1], m_regions.back());
m_regions.pop_back();
}
if (!removed.box.empty())
res.m_regions.push_back(std::move(removed));
}
return std::move(res);
}
UNICORN_EXPORT
uc_err uc_mem_protect(struct uc_struct *uc, uint64_t address, size_t size, uint32_t perms)
{
MemoryRegion *mr;
uint64_t addr = address;
size_t count, len;
bool remove_exec = false;
if (size == 0)
// trivial case, no change
return UC_ERR_OK;
// address must be aligned to uc->target_page_size
if ((address & uc->target_page_align) != 0)
return UC_ERR_ARG;
// size must be multiple of uc->target_page_size
if ((size & uc->target_page_align) != 0)
return UC_ERR_ARG;
// check for only valid permissions
if ((perms & ~UC_PROT_ALL) != 0)
return UC_ERR_ARG;
if (uc->mem_redirect) {
address = uc->mem_redirect(address);
}
// check that user's entire requested block is mapped
if (!check_mem_area(uc, address, size))
return UC_ERR_NOMEM;
// Now we know entire region is mapped, so change permissions
// We may need to split regions if this area spans adjacent regions
addr = address;
count = 0;
while(count < size) {
mr = memory_mapping(uc, addr);
len = MIN(size - count, mr->end - addr);
if (!split_region(uc, mr, addr, len, false))
return UC_ERR_NOMEM;
mr = memory_mapping(uc, addr);
// will this remove EXEC permission?
if (((mr->perms & UC_PROT_EXEC) != 0) && ((perms & UC_PROT_EXEC) == 0))
remove_exec = true;
mr->perms = perms;
uc->readonly_mem(mr, (perms & UC_PROT_WRITE) == 0);
count += len;
addr += len;
}
// if EXEC permission is removed, then quit TB and continue at the same place
if (remove_exec) {
uc->quit_request = true;
uc_emu_stop(uc);
}
return UC_ERR_OK;
}
