bit-shift

I want to create a 64-bit barrel shifter in verilog (rotate right for now). I want to know if there is a way to do it without writing a 65 part case statement? Is there a way to write some simple code such as: Y = {S[i - 1:0], S[63:i]}; I tried the code above in Xilinx and get an error: i is not a constant. Main Question: Is there a way to do this without a huge case statment? I've simplified some of the rules for clarity, but here are the details. In the statement Y = {S[i - 1:0], S[63:i]}; you have a concatenation of two signals, each with a constant part select. A constant part select is of

I want to use the following code in my program but gcc won't allow me to left shift my 1 beyond 31. sizeof(long int) displays 8, so doesn't that mean I can left shift till 63? #include <iostream> using namespace std; int main(){ long int x; x=(~0 & ~(1<<63)); cout<<x<<endl; return 0; } The compiling outputs the following warning: left shift `count >= width` of type [enabled by default] `x=(~0 & ~(1<<63))`; ^ and the output is -1. Had I left shifted 31 bits I get 2147483647 as expected of int. I am expecting all bits except the MSB to be turned on thus displaying the maximum value the datatype

Possible Duplicate: why is 1>>32 == 1? -1 as an int converted to binary is represented by 32 1's. When I right-shift it 31 times, I get 1 (31 0's and one 1). But when I right-shift it 32 times, I get -1 again. Shouldn't it be equal to 0? The Java specification explains the shift operators as follows: If the promoted type of the left-hand operand is int , only the five lowest-order bits of the right-hand operand are used as the shift distance. It is as if the right-hand operand were subjected to a bitwise logical AND operator & ( §15.22.1 ) with the mask value 0x1f . The shift distance actually

This is more of a language design rather than a programming question. The following is an excerpt from JLS 15.19 Shift Operators : If the promoted type of the left-hand operand is int , only the five lowest-order bits of the right-hand operand are used as the shift distance. If the promoted type of the left-hand operand is long , then only the six lowest-order bits of the right-hand operand are used as the shift distance. This behavior is also specified in C# , and while I'm not sure if it's in the official spec for Javascript (if there's one), it's also true based on my own test at least. The

Im having some trouble understanding how and why this code works the way it does. My partner in this assignment finished this part and I cant get ahold of him to find out how and why this works. I've tried a few different things to understand it, but any help would be much appreciated. This code is using 2's complement and a 32-bit representation. /* * fitsBits - return 1 if x can be represented as an * n-bit, two's complement integer. * 1 <= n <= 32 * Examples: fitsBits(5,3) = 0, fitsBits(-4,3) = 1 * Legal ops: ! ~ & ^ | + << >> * Max ops: 15 * Rating: 2 */ int fitsBits(int x, int n) { int r,

I'm very new to dealing with bits and have got stuck on the following warning when compiling: 7: warning: left shift count >= width of type My line 7 looks like this unsigned long int x = 1 << 32; This would make sense if the size of long on my system was 32 bits. However, sizeof(long) returns 8 and CHAR_BIT is defined as 8 suggesting that long should be 8x8 = 64 bits long. What am I missing here? Are sizeof and CHAR_BIT inaccurate or have I misunderstood something fundamental? long may be a 64-bit type, but 1 is still an int . You need to make 1 a long int using the L suffix: unsigned long x