When you build an application you can specify that a source file should be put the same location as its caller. However, how does this work when there are multiple callers?
There seems to be some logical loopholes in how the destination is determined in such cases.
To give an example (from LabVIEW 2012 for Windows, but it should apply to previous/other versions as well):
If a subVI of a VI that will be called dynamically (a plugin) and is destined to be put in an accompanying .llb file is calling a .dll file then the application builder will fail to put the subVI in the same llb as its caller. Instead it will put the subVI into the executable, even though the executable has no static calls to this subVI. The reason for this seems to be that the builder recognises that a dll is required, but instead of putting at the root where the llb file is it puts it together with the exe-file...and then from this it determines that the exe file is the caller, and hence it builds the subVIs calling this dll into the exe-file. The solution to this is to manually specify that the dll should be put in the directory of the llb...The builder will then recognise that the suBVIs are indeed called by the VI in the llb - and will put them into the llb file as well.
I do recognise that there are situations where it is only natural that the file cannot be placed one specific place. If the exe and some plugins share the same file I would expect the builder to prioritize the exe as a caller and include the file in the exe. However, if the exe is not a caller, and there are callers at multiple locations - then there is no single destination. It would be nice to get a warning about this perhaps, and then be able to specify where it should be put. I would then normally include it in the exe instead - and/or rewrite the plugins so that they will all expect it to be in one and the same location (i.e. not in their own llb for example, but a shared one).