blocks|key|4323264|text|如果您查看libc源代码，就会发现这是printf的实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4323265|整型|4323266|__printf+(const+char+*format,+...)
{
++va_list+arg;
++int+done;

++va_start+(arg,+format);
++done+=+vfprintf+(stdout,+format,+arg);
++va_end+(arg);

++return+done;
}|code-block|syntax|javascript|4323267|这不能告诉你太多..。它是一个变量函数，至少有一个参数，格式...它使用va_start生成一个va_list，并将其交给vfprintf来完成这项繁重的工作。|offset|length|style|CODE|4323268|它这样做是为了可以在所有printf流函数之间分担繁重工作，但这里是来自git://sourceware.org/git/glibc.git的libc源代码版本中的vfprintf，但是该文件很难理解，因为它是使用许多宏实现的。|4323269|但是，您可以通过扫描一个格式(这里我们不扫描一个格式，但只信任传入的参数编号)函数并对args执行操作来编写您自己的可变变量|4323270|#include+<stdio.h>
#include+<stdarg.h>

void+printNStrings(+int+n,+...)
{
++++va_list+l;
++++va_start(l,n);
++++for+(int+i=0;+i<+n;+i%2B%2B)
++++{
++++++++char+*+arg+=+va_arg(l,+char+*);
++++++++puts(arg);
++++}
++++va_end(l);

}


int+main(void)
{
++++printNStrings(2,"hello",+"world");
++++printNStrings(3,+"how",+"are",+"you");
++++return+0;

}|4323271|应该注意的是，这是一个危险的提议。因为va_arg只是从堆栈中拉出一个参数，并且没有任何状态可以存储有关边界的信息，所以：printNStrings(4,+"how",+"are",+"you");很快就会进入堆栈溢出和UB区域。编译器本身已经对printf家族函数进行了边界检查...您可以使用如下声明在流行的编译器上调用它们：void+mylogger(const+char+*format,+...)++__attribute__((format(printf,+1,+2)));，它将打开对传递到记录器中的类型的警告。|4323272|我仍然在寻找va_list在glibc中的实际实现，以作为参考。|4323273|entityMap^0|0|0|0|10|8|1C|7|1P|8|0|10|Y|2A|8|0|0|0|1P|12|4L|26|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@$K|14|L|15|M|N]|$K|16|L|17|M|N]|$K|18|L|19|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@$K|1B|L|1C|M|N]|$K|1D|L|1E|M|N]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1F|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|1G|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|1H|8|@$K|1I|L|1J|M|N]|$K|1K|L|1L|M|N]]|9|@]|A|$]]|$1|W|3|X|5|6|7|1M|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|Z|$]]

if you look in the libc source this is the implementation for printf:

int

<pre><code>__printf (const char *format, ...)
{
 va_list arg;
 int done;

 va_start (arg, format);
 done = vfprintf (stdout, format, arg);
 va_end (arg);

 return done;
}
</code></pre>

that doesn't tell you much... it is a variadic function taking at least one argument, the format... it makes a <code>va_list</code> with <code>va_start</code> and hands it to <code>vfprintf</code> which does the hard work.

it does this so it can share that hard work between all of the printf stream functions, but here is <code>vfprintf</code> in a source version of libc from <code>git://sourceware.org/git/glibc.git</code>, but the file is pretty hard to grok, because it is implemented with lots of macros.

but you can write you own variadic by scanning a format (here we wont scan a format but just trust an argument number passed in) function and acting on the args

<pre><code>#include &lt;stdio.h&gt;
#include &lt;stdarg.h&gt;

void printNStrings( int n, ...)
{
 va_list l;
 va_start(l,n);
 for (int i=0; i&lt; n; i++)
 {
 char * arg = va_arg(l, char *);
 puts(arg);
 }
 va_end(l);

}


int main(void)
{
 printNStrings(2,"hello", "world");
 printNStrings(3, "how", "are", "you");
 return 0;

}
</code></pre>

It should be noted that this is a dangerous proposition... because va_arg, just pulls an arg off of the stack and doesn't have any state that can store information about bounds so: <code>printNStrings(4, "how", "are", "you");</code> gets into stack overflow and UB territory quickly. The compiler's themselves have bounds checking for printf family functions... and you can invoke them on popular compilers with a declaration like: <code>void mylogger(const char *format, ...) __attribute__((format(printf, 1, 2)));</code> which will turn on warnings for the types passed into your logger.

I am still looking for the actual implimentation of va_list in glibc to use as a reference.

blocks|key|4323334|text|这个答案，对于clang，只是展示了我如何找到一个内置函数的实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4323335|我对std::atomic<T>的实现很感兴趣。如果T不是一个简单类型，那么clang使用锁来保护它的原子性。首先，我找到了一个名为__c11_atomic_store的内置函数。问题是，这个内置函数是如何在clang中实现的？|offset|length|style|CODE|4323336|在clang代码库中搜索Builtin，在clang/Basic/Builtins.def中查找|4323337|//+Some+of+our+atomics+builtins+are+handled+by+AtomicExpr+rather+than
//+as+normal+builtin+CallExprs.+This+macro+is+used+for+such+builtins.
#ifndef+ATOMIC_BUILTIN
#define+ATOMIC_BUILTIN(ID,+TYPE,+ATTRS)+BUILTIN(ID,+TYPE,+ATTRS)
#endif

//+C11+_Atomic+operations+for+<stdatomic.h>.
ATOMIC_BUILTIN(__c11_atomic_init,+"v.",+"t")
ATOMIC_BUILTIN(__c11_atomic_load,+"v.",+"t")
ATOMIC_BUILTIN(__c11_atomic_store,+"v.",+"t")
ATOMIC_BUILTIN(__c11_atomic_exchange,+"v.",+"t")
...|code-block|syntax|javascript|4323338|关键字是AtomicExpr和CallExpr。然后我检查了AtomicExpr的构造函数的每一个调用者，但是没有发现任何有用的信息，所以我猜测，可能在解析阶段，如果解析器匹配一个内置函数调用，它会构造一个带有内置标志的CallExpr到AST，在代码生成阶段，它会发出实现。|4323339|查看CodeGen，我在lib/CodeGen/CGBuiltin.cpp和CodeGen/CGAtomic.cpp中找到了答案。|4323340|你可以查看CodeGenFunction::EmitVAArg，我希望这会对你有帮助。|4323341|entityMap^0|0|2|E|Q|1|1U|I|0|C|7|L|O|0|0|4|A|F|8|U|A|32|8|0|2|7|C|P|12|K|0|5|Q|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@$D|Y|E|Z|F|G]|$D|10|E|11|F|G]|$D|12|E|13|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|14|8|@$D|15|E|16|F|G]|$D|17|E|18|F|G]]|9|@]|A|$]]|$1|J|3|K|5|L|7|19|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1A|8|@$D|1B|E|1C|F|G]|$D|1D|E|1E|F|G]|$D|1F|E|1G|F|G]|$D|1H|E|1I|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1J|8|@$D|1K|E|1L|F|G]|$D|1M|E|1N|F|G]|$D|1O|E|1P|F|G]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1Q|8|@$D|1R|E|1S|F|G]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|V|$]]

This answer, for clang, just show how I find implementation of a builtin function.

I'm interested in implementation of <code>std::atomic&lt;T&gt;</code>. If <code>T</code> is not a trivial type, clang use a lock to guard its atomicity. Look <a href="https://stackoverflow.com/questions/50298358/where-is-the-lock-for-a-stdatomic/50298847#50298847">this answer</a> first, I find a builtin function named <code>__c11_atomic_store</code>. The question is, how this builtin function implemented in clang?

Searching <code>Builtin</code> in clang codebase, find in <code>clang/Basic/Builtins.def</code>:

<pre><code>// Some of our atomics builtins are handled by AtomicExpr rather than
// as normal builtin CallExprs. This macro is used for such builtins.
#ifndef ATOMIC_BUILTIN
#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) BUILTIN(ID, TYPE, ATTRS)
#endif

// C11 _Atomic operations for &lt;stdatomic.h&gt;.
ATOMIC_BUILTIN(__c11_atomic_init, "v.", "t")
ATOMIC_BUILTIN(__c11_atomic_load, "v.", "t")
ATOMIC_BUILTIN(__c11_atomic_store, "v.", "t")
ATOMIC_BUILTIN(__c11_atomic_exchange, "v.", "t")
...
</code></pre>

The keyword are <code>AtomicExpr</code> and <code>CallExpr</code>. Then I check every caller of <code>AtomicExpr</code>'s constructor, but doesn't find any useful information. So I guess, maybe in parse phase, if parser match an builtin function calling, it will construct an <code>CallExpr</code> to AST with builtin flag. In code generate phase, it will emit the implementation.

Check <code>CodeGen</code>, I find the answer in <code>lib/CodeGen/CGBuiltin.cpp</code> and <code>CodeGen/CGAtomic.cpp</code>.

You can check <code>CodeGenFunction::EmitVAArg</code>, I holp that would be useful for you.

blocks|key|4323446|text|在Clang+9中，这是在|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4323447|clang\lib\AST\ASTContext.cpp|code-block|syntax|javascript|4323448|调用图：|4323449|getVaListTagDecl
=>getBuiltinVaListDecl
=>CreateVaListDecl
=>Create***BuiltinVaListDecl
for+example:
=>CreateCharPtrBuiltinVaListDecl
=>CreateCharPtrNamedVaListDecl
=>buildImplicitTypedef|4323450|当经过预处理的源代码中有__builtin_va_list时，编译器调用getVaListTagDecl来构建TypedefDecl+AST节点并将其插入到AST中，TypedefDecl在任何源代码中都不存在，它是在构建过程中动态生成的，就好像源代码中有这样的内容：|4323451|typedef+***+__builtin_va_list;
//for+example
typedef+char*+__builtin_va_list;|4323452|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

In Clang 9, this is implemented in 

<pre><code>clang\lib\AST\ASTContext.cpp
</code></pre>

call graph:

<pre><code>getVaListTagDecl
=&gt;getBuiltinVaListDecl
=&gt;CreateVaListDecl
=&gt;Create***BuiltinVaListDecl
for example:
=&gt;CreateCharPtrBuiltinVaListDecl
=&gt;CreateCharPtrNamedVaListDecl
=&gt;buildImplicitTypedef
</code></pre>

When there is __builtin_va_list in the preprocessed source, the compiler calls getVaListTagDecl to build a TypedefDecl AST node and insert it into the AST, the typedef doesn't exist in any source code, it is generated dynamically during build, as if there is such in the source:

<pre><code>typedef *** __builtin_va_list;
//for example
typedef char* __builtin_va_list;
</code></pre>

I want to delve into the implementation of function "printf" in C on macOS. "printf" uses the <code>&lt;stdarg.h&gt;</code> header file. I open the <code>&lt;stdarg.h&gt;</code> file and find that <code>va_list</code> is just a macro.

So, I am really curious about how the <code>__builtin_va_list</code> is implemented? I know it is compiler-specific. Where can I find the definition of the <code>__builtin_va_list</code>? Should I download the source code of clang compiler?

How is "__builtin_va_list" implemented?

我想深入研究在macOS上用C语言实现函数"printf“。"printf“使用<stdarg.h>头文件。我打开<stdarg.h>文件，发现va_list只是一个宏。所以，我真的很好奇__builtin_va_list是如何实现的？我知道它是特定于编译器的。在哪里可以找到__builtin_va_list的定义？我...

问"__builtin_va_list“是如何实现的？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问"__builtin_va_list“是如何实现的？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问"__builtin_va_list“是如何实现的？
EN