求助 C++ 的 mode(TI)

wayne

看到某人的C++ 代码,里面有一行看不懂, 求解释~~

  int64_t __attribute__((mode(TI))) a = p*q; a *= r;

gxqcn

引用自：http://stackoverflow.com/questio ... -modexx-actually-do

Q:

Hi All,

This arose from a question earlier today on the subject of bignum libraries and gcc specific hacks to the c language. Specifically, these two declarations were used:

1. typedef unsigned int dword_t __attribute__((mode(DI)));

复制代码

On 32 bit systems and

1. typedef unsigned int dword_t __attribute__((mode(TI)));

复制代码

On 64-bit systemms.

I assume given this is an extension to the C language that there exists no way to achieve whatever it achieves in current (C99) standards. So my questions are simple: is that assumption correct? And what do these statements do to the underlying memory? I think the result is I have 2xsizeof(uint32_t) for a dword in 32-bit systems and 2*sizeof(uint64_t) for 64-bit systems, am I correct?

Thanks for all your help,

A:

These allow you to explicitly specify a size for a type without depending on compiler or machine semantics, such as the size of 'long' or 'int'.

They are described fairly well on this page.

I quote from that page:

1. QI: An integer that is as wide as the smallest addressable unit, usually 8 bits.
   
2. HI: An integer, twice as wide as a QI mode integer, usually 16 bits.
   
3. SI: An integer, four times as wide as a QI mode integer, usually 32 bits.
   
4. DI: An integer, eight times as wide as a QI mode integer, usually 64 bits.
   
5. SF: A floating point value, as wide as a SI mode integer, usually 32 bits.
   
6. DF: A floating point value, as wide as a DI mode integer, usually 64 bits.

复制代码

So DI is essentially sizeof(char) * 8.

Further explanation, including TI mode, can be found here (possibly better than the first link, but both provided for reference).

So TI is essentially sizeof(char) * 16 (128 bits).

wayne

2# gxqcn

我看过了,不知道老大平时用过这个语句没

wayne

感觉把C++用到这种程度的一定是火星人

gxqcn

3# wayne


没用过。我倒是非常需要这样的数据结构。哪里有例程？

wayne

5# gxqcn
好像是gcc编译器带的,这有文档:
http://gcc.gnu.org/onlinedocs/gcc/X86-Built_002din-Functions.html

问题源自 projctEuler 221题的 讨论专栏里.
http://projecteuler.net/index.php?section=forum&id=221
答案是1884161251122450 ,你输进去即可查看所有人的讨论,
在我的楼下,有一位C++火星人提供的代码如下:

1. #include <cstdio>
   
2. #include <set>
   
3. #include <cmath>
   
4. #include <vector>
   
5. #include <cassert>
   
6. //1805315691966540?
   
7. 
   
8. int const cutoff = 200000;//1638400000;
   
9. int64_t const len = 1000000/*cutoff+2*/; //(int64_t)cutoff*cutoff+2;
   
10. 
    
11. int primeFac[len];
    
12. int primes[len/10];
    
13. int numPrimes;
    
14. 
    
15. std::vector<int64_t> factors(int64_t v, int64_t q)
    
16. {
    
17.     if(v == 1)
    
18.         return std::vector<int64_t>(1, 1);
    
19. 
    
20.     //int p = primeFac[v];
    
21.     int64_t p = v;
    
22.     for(int index = 0; primes[index] < q && index < numPrimes; ++index)
    
23.         if(v%primes[index] == 0)
    
24.     {
    
25.         p = primes[index];
    
26.         break;
    
27.     }
    
28.     int count = 0;
    
29.     //std::printf("* %ld %ld  %ld\n", v, p, q);
    
30.     //assert(v < len);
    
31.     //while(p == primeFac[v])
    
32.     while(v%p == 0)
    
33.     {
    
34.         ++count;
    
35.         v /= p;
    
36.         //std::printf("  %d %d\n", v, p);
    
37.     }
    
38.     std::vector<int64_t> ret = factors(v, std::min(2+(int64_t)sqrt(v), q));
    
39.     int siz = ret.size();
    
40.     for(int c = 0; c < count; ++c)
    
41.         for(int s = 0; s < siz; ++s)
    
42.             ret.push_back(ret[s+c*siz]*p);
    
43.     //std::printf("/ %ld %ld  %ld\n", v, p, q);
    
44.     return ret;
    
45. }
    
46. 
    
47. int main()
    
48. {
    
49.     for(int i = 0; i < len; ++i)
    
50.         primeFac[i] = i;
    
51.     for(int i = 2; i < len; ++i)
    
52.         if(primeFac[i] == i)
    
53.             for(int j = i; j < len; j += i)
    
54.                 primeFac[j] = i;
    
55. 
    
56.     numPrimes = 0;
    
57.     for(int i = 2; i < len; ++i)
    
58.         if(primeFac[i] == i)
    
59.             primes[numPrimes++] = i;
    
60. 
    
61.     std::vector<int64_t> test = factors(120, 120);
    
62.     for(std::vector<int64_t>::iterator i = test.begin(); i != test.end(); ++i)
    
63.         std::printf("%ld ", *i);
    
64.     std::printf("\n\n");
    
65. 
    
66.     std::set<uint64_t> A;
    
67. 
    
68.     // s = p+q
    
69.     for(int64_t q = 1; q <= cutoff; ++q)
    
70.     {
    
71.         int64_t zeroModS = q*q+1;
    
72.         std::vector<int64_t> S = factors(zeroModS, q);//std::min(q, 2000000000000000/(q*q)));
    
73.         if(q == 100000000)
    
74.         {
    
75.             std::printf("q = %ld\nS.size() = %zu\n", q, S.size());
    
76.             for(std::vector<int64_t>::iterator i = S.begin(); i != S.end(); ++i)
    
77.                 std::printf("    %lu\n", *i);
    
78.         }
    
79.         //for(int sign = -1; sign <= 1; sign += 2)
    
80.         int sign = -1;
    
81.         for(std::vector<int64_t>::iterator i = S.begin(); i != S.end(); ++i)
    
82.         {
    
83.             int64_t s = sign * *i;
    
84.             int64_t p = s-q;
    
85.             int64_t r = zeroModS/s-q; //-(p*q-1)/(p+q);
    
86.             int64_t __attribute__((mode(TI))) a = p*q; a *= r;
    
87.             if(a > 1 && a < 2000000000000000 && p < 2000000000000000/*(1LL<<62)*/)
    
88.                 A.insert(a);
    
89.         }
    
90.     }
    
91. 
    
92.     unsigned n = 0;
    
93.     for(std::set<uint64_t>::iterator i = A.begin(); i != A.end(); ++i)
    
94.     {
    
95.         ++n;
    
96.         std::printf("%lu\n", *i);
    
97.         if(n == 150000)
    
98.         {
    
99.             std::printf("Done\n");
    
100.             break;
     
101.         }
     
102.     }
     
103.     std::printf("set size = %zu\n", A.size());
     
104. }
     
105. 
     
106. /*
     
107. int main()
     
108. {
     
109.     int cutoff = 1000000000;
     
110.     std::set<uint64_t> a;
     
111.     for(int p = 1; p < cutoff; ++p)
     
112.     {
     
113.         int range = std::min(cutoff/p, p);
     
114.         for(int q = -range; q <= range; ++q)
     
115.             if(q != 0 && p+q != 0)
     
116.         {
     
117.             if(((int64_t)p*q-1) % (p+q) == 0)
     
118.             {
     
119.                 int r = -(p*q-1)/(p+q);
     
120.                 if(r < cutoff)
     
121.                     a.insert(std::max((int64_t)p*q*r, -(int64_t)p*q*r));
     
122.             }
     
123.         }
     
124.     }
     
125.     a.erase(0);
     
126.     unsigned n = 0;
     
127.     for(std::set<uint64_t>::iterator i = a.begin(); i != a.end(); ++i)
     
128.     {
     
129.         ++n;
     
130.         std::printf("%lu\n", *i);
     
131.         if(n == 150000)
     
132.         {
     
133.             std::printf("Done\n");
     
134.             break;
     
135.         }
     
136.     }
     
137.     std::printf("set size = %zu\n", a.size());
     
138. }
     
139. */

复制代码

gxqcn

这个限定是不是通知编译器可以向量优化？比如用MMX、SIMD、3DNow! 等汇编指令。

还有，标准C语言原生态整数类型是否最高仅支持到64位？128位的四则运算、位运算等还需要程序员自定义？

wayne

7# gxqcn
stackoverflow.com上的回答好像是在说，直接显式的指定一个类型的大小，而与编译器和机器类型无关。