radiance · commit

Use `bits.len` instead of `wordsFor`

f82c0aaaf6f32c2699ad5cca638bef285acd17291bf190ea3c5203b6da6b075a

Alexis Sellier committed 1 month ago 1 parent 087bce36

lib/std/lang/gen/bitset.rad +11 -12

}

/// Count the number of set bits.
pub fn count(bs: *Bitset) -> u32 {
    let mut total: u32 = 0;
    let numWords = wordsFor(bs.len);
    let numWords = bs.bits.len;
    for i in 0..numWords {
        total += popCount(bs.bits[i]);
    }
    return total;
}

    return n & 0x3F;
}

/// Union: `dst = dst | src`.
pub fn union_(dst: *mut Bitset, src: *Bitset) {
    let numWords = wordsFor(dst.len);
    let srcWords = wordsFor(src.len);
    let numWords = dst.bits.len;
    let srcWords = src.bits.len;
    let minWords = min(numWords, srcWords);
    for i in 0..minWords {
        dst.bits[i] |= src.bits[i];
    }
}

/// Subtract: `dst = dst - src`.
pub fn subtract(dst: *mut Bitset, src: *Bitset) {
    let numWords = wordsFor(dst.len);
    let srcWords = wordsFor(src.len);
    let numWords = dst.bits.len;
    let srcWords = src.bits.len;
    let minWords = min(numWords, srcWords);
    for i in 0..minWords {
        dst.bits[i] &= ~src.bits[i];
    }
}

/// Check if two bitsets are equal.
pub fn eq(a: *Bitset, b: *Bitset) -> bool {
    let numWordsA = wordsFor(a.len);
    let numWordsB = wordsFor(b.len);
    let numWordsA = a.bits.len;
    let numWordsB = b.bits.len;
    let maxWords = max(numWordsA, numWordsB);

    for i in 0..maxWords {
        let wordA = a.bits[i] if i < numWordsA else 0;
        let wordB = b.bits[i] if i < numWordsB else 0;

    return true;
}

/// Copy bits from source to destination.
pub fn copy(dst: *mut Bitset, src: *Bitset) {
    let numWords = wordsFor(dst.len);
    let srcWords = wordsFor(src.len);
    let numWords = dst.bits.len;
    let srcWords = src.bits.len;
    let minWords = min(numWords, srcWords);

    for i in 0..minWords {
        dst.bits[i] = src.bits[i];
    }

    }
}

/// Clear all bits.
pub fn clearAll(bs: *mut Bitset) {
    let numWords = wordsFor(bs.len);
    let numWords = bs.bits.len;
    for i in 0..numWords {
        bs.bits[i] = 0;
    }
}


    return BitIter { bs, wordIdx: 0, remaining };
}

/// Get the next set bit, or nil if none remain.
pub fn iterNext(it: *mut BitIter) -> ?u32 {
    let numWords = wordsFor(it.bs.len);

    let numWords = it.bs.bits.len;
    // Skip to next non-zero word.
    while it.remaining == 0 {
        it.wordIdx += 1;
        if it.wordIdx >= numWords {
            return nil;

lib/std/lang/gen/regalloc/liveness.rad +1 -1

    dst: *mut bitset::Bitset,
    liveOut: *bitset::Bitset,
    defs: *bitset::Bitset,
    uses: *bitset::Bitset
) -> bool {
    let numWords = bitset::wordsFor(dst.len);
    let numWords = dst.bits.len;
    let mut changed = false;
    for i in 0..numWords {
        let newWord = uses.bits[i] | (liveOut.bits[i] & ~defs.bits[i]);
        if dst.bits[i] != newWord {
            dst.bits[i] = newWord;

90	90		}
91	91
92	92		/// Count the number of set bits.
93	93		pub fn count(bs: *Bitset) -> u32 {
94	94		let mut total: u32 = 0;
95		-	let numWords = wordsFor(bs.len);
	95	+	let numWords = bs.bits.len;
96	96		for i in 0..numWords {
97	97		total += popCount(bs.bits[i]);
98	98		}
99	99		return total;
100	100		}

111	111		return n & 0x3F;
112	112		}
113	113
114	114		/// Union: `dst = dst \| src`.
115	115		pub fn union_(dst: mut Bitset, src: Bitset) {
116		-	let numWords = wordsFor(dst.len);
117		-	let srcWords = wordsFor(src.len);
	116	+	let numWords = dst.bits.len;
	117	+	let srcWords = src.bits.len;
118	118		let minWords = min(numWords, srcWords);
119	119		for i in 0..minWords {
120	120		dst.bits[i] \|= src.bits[i];
121	121		}
122	122		}
123	123
124	124		/// Subtract: `dst = dst - src`.
125	125		pub fn subtract(dst: mut Bitset, src: Bitset) {
126		-	let numWords = wordsFor(dst.len);
127		-	let srcWords = wordsFor(src.len);
	126	+	let numWords = dst.bits.len;
	127	+	let srcWords = src.bits.len;
128	128		let minWords = min(numWords, srcWords);
129	129		for i in 0..minWords {
130	130		dst.bits[i] &= ~src.bits[i];
131	131		}
132	132		}
133	133
134	134		/// Check if two bitsets are equal.
135	135		pub fn eq(a: Bitset, b: Bitset) -> bool {
136		-	let numWordsA = wordsFor(a.len);
137		-	let numWordsB = wordsFor(b.len);
	136	+	let numWordsA = a.bits.len;
	137	+	let numWordsB = b.bits.len;
138	138		let maxWords = max(numWordsA, numWordsB);
139	139
140	140		for i in 0..maxWords {
141	141		let wordA = a.bits[i] if i < numWordsA else 0;
142	142		let wordB = b.bits[i] if i < numWordsB else 0;

147	147		return true;
148	148		}
149	149
150	150		/// Copy bits from source to destination.
151	151		pub fn copy(dst: mut Bitset, src: Bitset) {
152		-	let numWords = wordsFor(dst.len);
153		-	let srcWords = wordsFor(src.len);
	152	+	let numWords = dst.bits.len;
	153	+	let srcWords = src.bits.len;
154	154		let minWords = min(numWords, srcWords);
155	155
156	156		for i in 0..minWords {
157	157		dst.bits[i] = src.bits[i];
158	158		}

162	162		}
163	163		}
164	164
165	165		/// Clear all bits.
166	166		pub fn clearAll(bs: *mut Bitset) {
167		-	let numWords = wordsFor(bs.len);
	167	+	let numWords = bs.bits.len;
168	168		for i in 0..numWords {
169	169		bs.bits[i] = 0;
170	170		}
171	171		}
172	172

186	186		return BitIter { bs, wordIdx: 0, remaining };
187	187		}
188	188
189	189		/// Get the next set bit, or nil if none remain.
190	190		pub fn iterNext(it: *mut BitIter) -> ?u32 {
191		-	let numWords = wordsFor(it.bs.len);
192		-
	191	+	let numWords = it.bs.bits.len;
193	192		// Skip to next non-zero word.
194	193		while it.remaining == 0 {
195	194		it.wordIdx += 1;
196	195		if it.wordIdx >= numWords {
197	196		return nil;

146	146		dst: *mut bitset::Bitset,
147	147		liveOut: *bitset::Bitset,
148	148		defs: *bitset::Bitset,
149	149		uses: *bitset::Bitset
150	150		) -> bool {
151		-	let numWords = bitset::wordsFor(dst.len);
	151	+	let numWords = dst.bits.len;
152	152		let mut changed = false;
153	153		for i in 0..numWords {
154	154		let newWord = uses.bits[i] \| (liveOut.bits[i] & ~defs.bits[i]);
155	155		if dst.bits[i] != newWord {
156	156		dst.bits[i] = newWord;