Intial Thumb2 Sandbox (naclrev 6680)

src/trusted/validator_arm/address_set.cc

Index: src/trusted/validator_arm/address_set.cc
diff --git a/src/trusted/validator_arm/address_set.cc b/src/trusted/validator_arm/address_set.cc
index 3c9b8bc20404d8d6557aa032964ab12048fe9a9d..ba507f530e7c46435552abce231ee4db6012cbee 100644
--- a/src/trusted/validator_arm/address_set.cc
+++ b/src/trusted/validator_arm/address_set.cc
@@ -9,11 +9,13 @@
 #include <stdio.h>
 #include <string.h>
 
+#define ADDRFACTOR sizeof(uint16_t)
+
 namespace nacl_arm_val {
 
 AddressSet::AddressSet(uint32_t base, uint32_t size)

[Karl, 2011/08/30 19:53:52]

There appears to be inconsistencies between sizes. The argument base is 32-bits,
but ADDRFACTOR is based on 16?

-    : base_(base), size_(size), bits_(new uint32_t[(size + 3) / 4]) {
-  memset(bits_, 0, sizeof(uint32_t) * ((size + 3) / 4));
+    : base_(base), size_(size), bits_(new uint32_t[(size + 3) / ADDRFACTOR]) {

[Karl, 2011/08/30 19:53:52]

Isn't 3 based on ADDRFACTOR?

+  memset(bits_, 0, sizeof(uint32_t) * ((size + 3) / ADDRFACTOR));
 }
 
 AddressSet::~AddressSet() {
@@ -22,7 +24,7 @@ AddressSet::~AddressSet() {
 
 void AddressSet::add(uint32_t address) {
   if ((address - base_) < size_) {
-    uint32_t word_address = (address - base_) / sizeof(uint32_t);
+    uint32_t word_address = (address - base_) / ADDRFACTOR;
 
     bits_[word_address / 32] |= 1 << (word_address % 32);

[Karl, 2011/08/30 19:53:52]

Doesn't 32 conflict with size of ADDRFACTOR?

   }
@@ -30,7 +32,7 @@ void AddressSet::add(uint32_t address) {
 
 bool AddressSet::contains(uint32_t address) const {
   if ((address - base_) < size_) {
-    uint32_t word_address = (address - base_) / sizeof(uint32_t);
+    uint32_t word_address = (address - base_) / ADDRFACTOR;
 
     return bits_[word_address / 32] & (1 << (word_address % 32));

[Karl, 2011/08/30 19:53:52]

Again, is 32 consistent with ADDRFACTOR?

   } else {
@@ -64,11 +66,11 @@ bool AddressSet::Iterator::operator!=(const AddressSet::Iterator &other) const {
 }
 
 uint32_t AddressSet::Iterator::operator*() const {
-  return parent_.base_ + 4 * ((index_ * 32) + shift_);
+  return parent_.base_ + ADDRFACTOR * ((index_ * 32) + shift_);
 }
 
 void AddressSet::Iterator::advance() {
-  uint32_t max_index = (parent_.size_ + 3) / 4;
+  uint32_t max_index = (parent_.size_ + 3) / ADDRFACTOR;

[bsy, 2011/09/01 00:30:00]

s/3/(ADDRFACTOR-1)/?

[jasonwkim, 2011/09/16 20:09:16]

Done

 
   for (; index_ < max_index; index_++) {
     uint32_t word = (shift_ > 31)? 0 : parent_.bits_[index_] >> shift_;

[Karl, 2011/08/30 19:53:52]

Does this conflict with ADDRFACTOR value?