search for: shifted

I am getting the following message when Shorewall stops can anybody shed any light on this message and where I should be looking? Thanks root@bobshost:~# shorewall stop Loading /usr/share/shorewall/functions... Processing /etc/shorewall/params ... Processing /etc/shorewall/shorewall.conf... Loading Modules... Stopping Shorewall...Processing /etc/shorewall/stop ... IP Forwarding Enabled

Hi all, I'm running a monte carlo test of a neural network tool I've developed, and it looks like it's going to take a very long time if I run it in R so I'm interested in translating my code (included below) into something faster like Fortran (which I'll have to learn from scratch). However, as you'll see my code loads the nnet library and uses it quite a bit, and I

...(at worst) > removed UB in the original program? Yes. zext and sext are equivalent for non-negative inputs. For negative inputs, sext will produce negative output. And interpreted as unsigned number, such negative shift amount is *always* bigger than largest legal shift amount: * i1 can only be shifted by 0 * i2 can only be shifted by 1 (positive); 2,3 (negative) are not legal shift amounts * i3 can only be shifted by 1,2 (positive); 3 (positive) and 4-7 (negative) are not legal shift amounts * i4 can only be shifted by 1,2,3 (positive); 4-7 (positive) and 8-15 (negative) are not legal shift amou...

...Original Message----- > From: Sanjay Patel > Sent: Monday, February 25, 2019 10:30 PM > Subject: Re: [llvm-dev] funnel shift, select, and poison > > > Don't we need to distinguish funnel shift from the more specific rotate? > I'm not seeing how rotate (a single input op shifted by some amount) gets > into trouble like funnel shift (two variables concatenated and shifted by > some amount). > Eg, if in pseudo IR we have: > %funnel_shift = fshl %x, %y, %sh ; this is problematic because either x or > y > can be poison, but we may not touch the poison when sh...

...gt;> Yes. >> zext and sext are equivalent for non-negative inputs. >> For negative inputs, sext will produce negative output. >> And interpreted as unsigned number, such negative shift amount >> is *always* bigger than largest legal shift amount: >> * i1 can only be shifted by 0 >> * i2 can only be shifted by 1 (positive); 2,3 (negative) are not legal >> shift amounts >> * i3 can only be shifted by 1,2 (positive); 3 (positive) and 4-7 >> (negative) are not legal shift amounts >> * i4 can only be shifted by 1,2,3 (positive); 4-7 (positive)...

Hi, > I'm working in adding support for 64-bit integers to my target. I'm using > LLVM to decompose the 64-bit integer operations by using 32-bit registers > wherever possible and emulating support where not. When looking at the bit > shift decomposition I saw what seems to be a bug in the implementation. The > affected function is ExpandShiftWithUnknownAmountBit in >

In https://reviews.llvm.org/D68103 the InstCombine learned that shift-by-sext is simply a shift-by-zext. But the transform is limited to single-use sext. We can quite trivially get a case where there are two shifts by the same sext: https://godbolt.org/z/j6mO3t <- We should handle those cases. In https://reviews.llvm.org/D68103#1686130 Sanjay Patel notes that this sext is intrusive for

Hi Duncan, The problem is the implementation of the expansion. Perhaps an example can help illustrate better. Take the case of a 64-bit integer shifted left by say 6 bits and is decomposed using 32-bit registers. Because 6 is less than the 32 (the register size) the resulting low part should be equal to the source low part shifted left by 6 bits. The current implementation places a zero instead. All other values have similar errors. Below is...

Don't we need to distinguish funnel shift from the more specific rotate? I'm not seeing how rotate (a single input op shifted by some amount) gets into trouble like funnel shift (two variables concatenated and shifted by some amount). Eg, if in pseudo IR we have: %funnel_shift = fshl %x, %y, %sh ; this is problematic because either x or y can be poison, but we may not touch the poison when sh==0 %rotate = fshl %x, %x, %sh...

Hi all, I was trying to test ROUTE specific code with a multi-isp serviced box. There is a bug somewhere, but I''m not able to understand what the real problem is: when I issue a "shorewall show capabilities" I get: Loading /usr/share/shorewall/functions... Processing /etc/shorewall/params ... Processing /etc/shorewall/shorewall.conf... Loading Modules... Shorewall has

...> Sent: Monday, February 25, 2019 10:30 PM > > Subject: Re: [llvm-dev] funnel shift, select, and poison > > > > > > Don't we need to distinguish funnel shift from the more specific > rotate? > > I'm not seeing how rotate (a single input op shifted by some amount) > > gets > > into trouble like funnel shift (two variables concatenated and > > shifted by > > some amount). > > Eg, if in pseudo IR we have: > > %funnel_shift = fshl %x, %y, %sh ; this is problematic because > >...

...equivalent for non-negative inputs. > > >> For negative inputs, sext will produce negative output. > > >> And interpreted as unsigned number, such negative shift amount > > >> is *always* bigger than largest legal shift amount: > > >> * i1 can only be shifted by 0 > > >> * i2 can only be shifted by 1 (positive); 2,3 (negative) are not legal > > >> shift amounts > > >> * i3 can only be shifted by 1,2 (positive); 3 (positive) and 4-7 > > >> (negative) are not legal shift amounts > > >> * i4 can o...

On 7/2/2018 3:16 PM, Sanjay Patel wrote: > I also agree that the per-element rotate for vectors is what we want for > this intrinsic. > > So I have this so far: > > declare i32 @llvm.catshift.i32(i32 %a, i32 %b, i32 %shift_amount) > declare <2 x i32> @llvm.catshift.v2i32(<2 x i32> %a, <2 x i32> %b, <2 x i32> %shift_amount) > > For

...he inputs), then the transform should be allowed? This transform was implemented in instcombine [3] with the motivation of reducing UB-safe rotate code in C to the LLVM intrinsic [4]. So a potential sidestep of the problem would be to limit that transform to a rotate pattern (single value is being shifted) rather than the more general funnel pattern (two values are being shifted). [1] https://llvm.org/docs/LangRef.html#llvm-fshl-intrinsic [2] http://llvm.1065342.n5.nabble.com/poison-and-select-td72262.html [3] https://reviews.llvm.org/D54552 [4] https://bugs.llvm.org/show_bug.cgi?id=34924 ---------...

Hi, is there any function in R that shifts elements of a vector to the opposite direction of what Lag() of the Hmisc package does? (something like, Lag(x, shift = -1) ) Thanks Zava -------------------------------------------------------- This is not an offer (or solicitation of an offer) to buy/se...{{dropped}}

Yes, this is such a case. However, implementing this in a future encoder/decoder would break compatibility with most (likely all) existing decoders, and only in some very, very rare cases where the material is such that the encoder chooses to use negative shifts, which makes it even harder to troubleshoot. Furthermore, as this can only be used in very rare cases, there is no benefit from allowing

In 780427f0e11 (Indicate that clock was set in the pvclock gtod notifier), logic was added to pass a CLOCK_WAS_SET notification to the pvclock notifier chain. While that patch added a action flag returned from accumulate_nsecs_to_secs(), it only uses the returned value in one location, and not in the logarithmic accumulation. This means if a leap second triggered during the logarithmic

System config:- bash-3.2# ifconfig -a lo0: flags=2001000849<UP,LOOPBACK,RUNNING,MULTICAST,IPv4,VIRTUAL> mtu 8232 index 1 inet 127.0.0.1 netmask ff000000 rge0: flags=201004843<UP,BROADCAST,RUNNING,MULTICAST,DHCP,IPv4,CoS> mtu 1500 index 2 inet 192.168.1.53 netmask ffffff00 broadcast 192.168.1.255 ether 0:1e:8c:25:cc:a5 lo0:

...2) <4 x i32> @llvm.sshl.sat.v4i32(<4 x i32>, <4 x i32>) <4 x i32> @llvm.ushl.sat.v4i32(<4 x i32>, <4 x i32>) and are overloaded with a single type which can be either an integer type or a vector of integers. The value(s) provided in the first operand are shifted left by the amount(s) given by the second operand. As with regular left shift instructions, the second operand is an unsigned quantity and must be less than the integer bitwidth. If the true result of the operation (given infinite precision) lies outside of the maximum or minimum representable val...

...th "window" columns filled with "v" by filling a row, then shifting over "shift" and continuing to the next row until "v" is exhausted. You can assume "v" will evenly fit "m" so the result needs to look like this matrix where each row is shifted 2 (in this case): > m [,1] [,2] [,3] [,4] [,5] [1,] "a" "b" "c" "d" "e" [2,] "c" "d" "e" "f" "g" [3,] "e" "f" "g" "h" "i"...