search for: unknownsize

...s are related by the getelementptr 1298     // instruction.  If one pointer is a GEP with a non-zero index of the other 1299     // pointer, we know they cannot alias. 1300 1301     // If both accesses are unknown size, we can't do anything useful here. 1302     if (V1Size == MemoryLocation::UnknownSize && 1303         V2Size == MemoryLocation::UnknownSize) 1304       return MayAlias; 1305 1306     AliasResult R = aliasCheck(UnderlyingV1, MemoryLocation::UnknownSize, 1307                                AAMDNodes(), V2, MemoryLocation::UnknownSize, 1308                                V2AA...

On 11/17/2017 02:01 AM, Hongbin Zheng wrote: > Do you mean a and b are noalias if: > > static int foo(int *a, int *b) { > return a[0] + b[0]; > } > > int bar(int *x) { > return foo(x+1, x); > } > > ? > > To me, because "AA.alias((x+1, MemoryLocation::UnknownSize), > (x, MemoryLocation::UnknownSize)) != NoAlias", so a and b are not noalias. Remember that MemoryLocation::UnknownSize is unknown, but positive. So you need to check both "AA.alias((x+1, MemoryLocation::UnknownSize), (x, MemoryLocation::UnknownSize)) == NoAlias" and "AA...

On 11/17/2017 01:49 AM, Hongbin Zheng wrote: > Could you elaborate "Note that, without further analysis of the uses > of the potentially-noalias pointers, you can do this only ..."? > Why the uses, instead of the def, of pointer matter? Both matter. static int foo(int *a, int *b) { return a[0] + b[1]; } int bar(int *x) { return foo(x+1, x); } You can't mark a and

...lists.llvm.org>: > All I am expecting from DA is a direction vector containing (*). There seems to be a bug in DI, see Felipe's answer. > I think the main problem is that currently there is no exact way DA can query AliasAnalysis in a ‘conservatively correct’ manner. > > Using UnknownSize seems to be an approximate solution (workaround). Passing an unknown size is conservatively correct. That is, it must be correct for any possible size. Yes, we could be better if we know all the array elements that are accessed. Unfortunately it is also difficult, e.g. because the access range de...

...quot;?????? 360 return true; 361 } Figure 2 cat -n lib/Analysis/BasicAliasAnalysis.cpp 1205 // If the size of one access is larger than the entire object on the other 1206 // side, then we know such behavior is undefined and can assume no alias. 1207 if (TD) 1208 if ((V1Size != UnknownSize && isObjectSmallerThan(O2, V1Size, *TD, *TLI)) || 1209 (V2Size != UnknownSize && isObjectSmallerThan(O1, V2Size, *TD, *TLI))) 1210 return NoAlias; -------------- next part -------------- ; ModuleID = 'a.c' target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-...

...; > Figure 2 > cat -n lib/Analysis/BasicAliasAnalysis.cpp > 1205 // If the size of one access is larger than the entire object > on the other > 1206 // side, then we know such behavior is undefined and can > assume no alias. > 1207 if (TD) > 1208 if ((V1Size != UnknownSize && isObjectSmallerThan(O2, > V1Size, *TD, *TLI)) || > 1209 (V2Size != UnknownSize && isObjectSmallerThan(O1, > V2Size, *TD, *TLI))) > 1210 return NoAlias;

...Figure 2 >> cat -n lib/Analysis/BasicAliasAnalysis.cpp >> 1205 // If the size of one access is larger than the entire object on the other >> 1206 // side, then we know such behavior is undefined and can assume no alias. >> 1207 if (TD) >> 1208 if ((V1Size != UnknownSize && isObjectSmallerThan(O2, V1Size, *TD, *TLI)) || >> 1209 (V2Size != UnknownSize && isObjectSmallerThan(O1, V2Size, *TD, *TLI))) >> 1210 return NoAlias; Best, Arnold

Am Mi., 18. März 2020 um 18:15 Uhr schrieb Chawla, Pankaj <pankaj.chawla at intel.com>: > > >> DependenceInfo is not using the AA interface correctly. Either DI has to be fixed, or another method added to AA that gives additional guarantees. Please see the bug report for details. > > Thanks for updating the bug report but GetUnderlyingObject() doesn't help in this case.

...t; cat -n lib/Analysis/BasicAliasAnalysis.cpp >>> 1205 // If the size of one access is larger than the entire object on the other >>> 1206 // side, then we know such behavior is undefined and can assume no alias. >>> 1207 if (TD) >>> 1208 if ((V1Size != UnknownSize && isObjectSmallerThan(O2, V1Size, *TD, *TLI)) || >>> 1209 (V2Size != UnknownSize && isObjectSmallerThan(O1, V2Size, *TD, *TLI))) >>> 1210 return NoAlias; > Best, > Arnold

Hi, RFC Im adding 2 new functions to the AliasAnalysis interface: 1) ModRefSameBufferCheck: this function will receive 2 memoryLocation as parameters, and returns true if the parameters are modifying or refering the same buffer or same memory block, false otherwise. 2) getAddressesDistance: the function will recieve 2 memoryLocation, if they are mod/ref-ing the same buffer/memory block, the

...alysis/BasicAliasAnalysis.cpp >>>> 1205 // If the size of one access is larger than the entire object on the other >>>> 1206 // side, then we know such behavior is undefined and can assume no alias. >>>> 1207 if (TD) >>>> 1208 if ((V1Size != UnknownSize && isObjectSmallerThan(O2, V1Size, *TD, *TLI)) || >>>> 1209 (V2Size != UnknownSize && isObjectSmallerThan(O1, V2Size, *TD, *TLI))) >>>> 1210 return NoAlias; >> Best, >> Arnold >

AliasAnalysis and dependence analysis answer different problems. AA check whether two memory ranges accessed at the same time (i.e. in the same iteration) do not overlap. DI checks when two accesses, not necessarily executed in the same iteration, do overlap. DI makes use of AA in verifying that the base pointer (with unknown size), at the beginning of the loop, themselves do not overlap. If they

...sAnalysis.cpp >>>>> 1205 // If the size of one access is larger than the entire object on the other >>>>> 1206 // side, then we know such behavior is undefined and can assume no alias. >>>>> 1207 if (TD) >>>>> 1208 if ((V1Size != UnknownSize && isObjectSmallerThan(O2, V1Size, *TD, *TLI)) || >>>>> 1209 (V2Size != UnknownSize && isObjectSmallerThan(O1, V2Size, *TD, *TLI))) >>>>> 1210 return NoAlias; >>> Best, >>> Arnold

You might want to look more carefully at how you're constructing the MemoryLocation.   The first argument is a pointer, and the second argument is the number of bytes pointed to by that pointer (or MemoryLocation::UnknownSize if the number of bytes accessed isn't known). More generally, copy-pasting code you don't understand isn't a good idea. -Eli On 5/22/2018 4:02 PM, Dávid Bolvanský wrote: > IR: > define i32 @calloc_strlen_write_between() { >   %call = tail call noalias i8* @calloc(i32 10, i32...

...) > channel RODB Connection 1 Details: case=tolower DSN=crtedb DATABASE=valid SERVER=10.3.1.91 PORT=5432 SSLMODE=prefer UID=uleopold PWD=****** ReadOnly=Yes FakeOidIndex=No ShowOidColumn=No RowVersioning=No ShowSystemTables=No ConnSettings= Fetch=100 Socket=8192 UnknownSizes=0 MaxVarcharSize=254 MaxLongVarcharSize=8190 Debug=0 CommLog=0 Optimizer=1 Ksqo=1 UseDeclareFetch=0 TextAsLongVarchar=1 UnknownsAsLongVarchar=0 BoolsAsChar=1 Parse=0 CancelAsFreeStmt=0 ExtraSysTablePrefixes=dd_ LFConversion=0 UpdatableCursors=0 DisallowPremature=0...

...GMT+02:00 Friedman, Eli <efriedma at codeaurora.org>: > You might want to look more carefully at how you're constructing the > MemoryLocation. The first argument is a pointer, and the second argument > is the number of bytes pointed to by that pointer (or > MemoryLocation::UnknownSize if the number of bytes accessed isn't known). > > More generally, copy-pasting code you don't understand isn't a good idea. > > -Eli > > > On 5/22/2018 4:02 PM, Dávid Bolvanský wrote: > > IR: > define i32 @calloc_strlen_write_between() { > %call = tail...

Hi, I'm trying to establish a connection to a MySQL database, and am using the rodbc package for it. This is in a GNU/Debian Linux box, with the corresponding Debian unstable packages. I can login to my MySQL databases from any shell and directory, so the problem is probably not there. Here's an example of what I'm doing: R> odbcConnect("test",

...l is uncommon, and in some sense it is, but this is exactly what the loop vectorizer does when partitioning memory accesses in a loop into potential aliasing sets. The loop vectorizer partitions a loop's memory accesses by taking the access's natural Location object, and setting the size to UnknownSize (the largest representable size) and querying using that infinite-size Location. The logic is that if two access don't alias with both sizes set to infinity, then they must always come from disjoint sets of underlying objects, and because the vectorizer only considers access pointers that are l...

IR: define i32 @calloc_strlen_write_between() { %call = tail call noalias i8* @calloc(i32 10, i32 1) store i8 97, i8* %call, align 1 %call1 = tail call i32 @strlen(i8* %call) ret i32 %call1 } static bool eliminateStrlen(CallInst *CI, BasicBlock::iterator &BBI, AliasAnalysis *AA, MemoryDependenceResults *MD, const DataLayout &DL, const TargetLibraryInfo *TLI,

It works with MemoryLocation MemoryLocation::get(const CallInst *CI) { AAMDNodes AATags; CI->getAAMetadata(AATags); const auto &DL = CI->getModule()->getDataLayout(); return MemoryLocation(CI, DL.getTypeStoreSize(CI->getType()), AATags); } Is it fine? :) 2018-05-22 23:56 GMT+02:00 Dávid Bolvanský <david.bolvansky at gmail.com>: > Looks like there are many overloads