[cfe-dev] suspecting a bug in Clang

Christudasan D via cfe-dev cfe-dev at lists.llvm.org
Wed Sep 7 21:08:25 PDT 2016


I am facing a problem with LLVM 3.5 Compiler and suspect it is a bug in the
clang. I earlier posted this query to llvm-dev list.

Here is my observation.

I am trying to support a target specific function attribute for a
particular target machine.

Having followed the steps specified in the compiler documentation, I see
the attribute is passed to the backend if we include the attribute in the
function definition. But this attribute is not propagate to the backend if
I include it only in the function’s prototype/declaration (in the C

This virtual function (given below) invocation in
clang/lib/CodeGen/CodeGenModule.cpp in clang is responsible for attaching
the target specific attributes to the backend CodeGen objects (functions,
variables etc.)

getTargetCodeGenInfo().SetTargetAttributes(D, GO, *this)

I found that this virtual function is getting invoked only for function
definitions and not for function declarations.

Actual requirement:

Along with regular C functions we have special functions supported in the
target and its definition and invocation will always come in different
compilation units. There must be a way to recognize these special functions
at the call-sites during codegen in the backend. By attaching some info in
the function prototype, we can recognize these special functions at the
call-site during backend codegen. That’s why I thought of a new target
specific attribute to achieve this purpose.

*Is it really a bug?*

When I compile a program having function declarations/prototypes with
generic attributes like __attribute__((*const*)), clang will add it to that
function’s attributelist in the IR and it will be available in the backend.

Similarly I expected the target specific attribute should also be added to
the attributelist available in the backend and I should be able to identify
it using *F.hasFnAttribute("XYZ")*, where XYZ is the new attribute name.

I understand that a look-up in the prototype for function-attrs is very
rare at codegen. But I was keen to ask this when I found that the standard
attributes (*'const',* for example) are actually propagated to the backend
through function prototype.

In the sample program below I have declared function *foo* with attribute '
*const'* and you can see '*readnone'* is added to the attribute list.

*Sample Program:*

extern void __attribute__((const)) foo (int);

int main ()
int  my_var = 45;

return 0;
*Generated IR:*

; Function Attrs: nounwind
define i16 @main() #0 {
  %1 = alloca i16, align 2
  %my_var = alloca i16, align 2
  store i16 0, i16* %1
  call void @llvm.dbg.declare(metadata !{i16* %my_var}, metadata !13), !dbg
  store i16 45, i16* %my_var, align 2, !dbg !15
  %2 = load i16* %my_var, align 2, !dbg !16
  call void @foo(i16 %2) #1, !dbg !16
  ret i16 0, !dbg !17

; Function Attrs: nounwind readnone
declare void @llvm.dbg.declare(metadata, metadata) #1

; Function Attrs: nounwind *readnone*
declare void @foo(i16) #2

Since I work with LLVM 3.5 code-base, I am not sure whether this issue (if
it is really a bug) has already been fixed with recent compiler releases.

Please write to me.


-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-dev/attachments/20160908/b5c4ae38/attachment.html>

More information about the cfe-dev mailing list