ms-x86-primary-bases.cpp 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329
  1. // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
  2. // RUN: | FileCheck %s
  3. // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
  4. // RUN: | FileCheck %s -check-prefix CHECK-X64
  5. extern "C" int printf(const char *fmt, ...);
  6. struct B0 { int a; B0() : a(0xf00000B0) { printf("B0 = %p\n", this); } virtual void f() { printf("B0"); } };
  7. struct B1 { int a; B1() : a(0xf00000B1) { printf("B1 = %p\n", this); } virtual void g() { printf("B1"); } };
  8. struct B2 { int a; B2() : a(0xf00000B2) { printf("B1 = %p\n", this); } };
  9. struct B0X { int a; B0X() : a(0xf00000B0) {} };
  10. struct B1X { int a; B1X() : a(0xf00000B1) {} virtual void f() { printf("B0"); } };
  11. struct B2X : virtual B1X { int a; B2X() : a(0xf00000B2) {} };
  12. struct A : virtual B0 {
  13. };
  14. // CHECK: *** Dumping AST Record Layout
  15. // CHECK: *** Dumping AST Record Layout
  16. // CHECK-NEXT: 0 | struct A
  17. // CHECK-NEXT: 0 | (A vbtable pointer)
  18. // CHECK-NEXT: 4 | struct B0 (virtual base)
  19. // CHECK-NEXT: 4 | (B0 vftable pointer)
  20. // CHECK-NEXT: 8 | int a
  21. // CHECK-NEXT: | [sizeof=12, align=4
  22. // CHECK-NEXT: | nvsize=4, nvalign=4]
  23. // CHECK-X64: *** Dumping AST Record Layout
  24. // CHECK-X64: *** Dumping AST Record Layout
  25. // CHECK-X64-NEXT: 0 | struct A
  26. // CHECK-X64-NEXT: 0 | (A vbtable pointer)
  27. // CHECK-X64-NEXT: 8 | struct B0 (virtual base)
  28. // CHECK-X64-NEXT: 8 | (B0 vftable pointer)
  29. // CHECK-X64-NEXT: 16 | int a
  30. // CHECK-X64-NEXT: | [sizeof=24, align=8
  31. // CHECK-X64-NEXT: | nvsize=8, nvalign=8]
  32. struct B : virtual B0 {
  33. virtual void f() { printf("B"); }
  34. };
  35. // CHECK: *** Dumping AST Record Layout
  36. // CHECK-NEXT: 0 | struct B
  37. // CHECK-NEXT: 0 | (B vbtable pointer)
  38. // CHECK-NEXT: 4 | struct B0 (virtual base)
  39. // CHECK-NEXT: 4 | (B0 vftable pointer)
  40. // CHECK-NEXT: 8 | int a
  41. // CHECK-NEXT: | [sizeof=12, align=4
  42. // CHECK-NEXT: | nvsize=4, nvalign=4]
  43. // CHECK-X64: *** Dumping AST Record Layout
  44. // CHECK-X64-NEXT: 0 | struct B
  45. // CHECK-X64-NEXT: 0 | (B vbtable pointer)
  46. // CHECK-X64-NEXT: 8 | struct B0 (virtual base)
  47. // CHECK-X64-NEXT: 8 | (B0 vftable pointer)
  48. // CHECK-X64-NEXT: 16 | int a
  49. // CHECK-X64-NEXT: | [sizeof=24, align=8
  50. // CHECK-X64-NEXT: | nvsize=8, nvalign=8]
  51. struct C : virtual B0 {
  52. virtual void g() { printf("A"); }
  53. };
  54. // CHECK: *** Dumping AST Record Layout
  55. // CHECK-NEXT: 0 | struct C
  56. // CHECK-NEXT: 0 | (C vftable pointer)
  57. // CHECK-NEXT: 4 | (C vbtable pointer)
  58. // CHECK-NEXT: 8 | struct B0 (virtual base)
  59. // CHECK-NEXT: 8 | (B0 vftable pointer)
  60. // CHECK-NEXT: 12 | int a
  61. // CHECK-NEXT: | [sizeof=16, align=4
  62. // CHECK-NEXT: | nvsize=8, nvalign=4]
  63. // CHECK-X64: *** Dumping AST Record Layout
  64. // CHECK-X64-NEXT: 0 | struct C
  65. // CHECK-X64-NEXT: 0 | (C vftable pointer)
  66. // CHECK-X64-NEXT: 8 | (C vbtable pointer)
  67. // CHECK-X64-NEXT: 16 | struct B0 (virtual base)
  68. // CHECK-X64-NEXT: 16 | (B0 vftable pointer)
  69. // CHECK-X64-NEXT: 24 | int a
  70. // CHECK-X64-NEXT: | [sizeof=32, align=8
  71. // CHECK-X64-NEXT: | nvsize=16, nvalign=8]
  72. struct D : virtual B2, virtual B0 {
  73. virtual void f() { printf("D"); }
  74. virtual void g() { printf("D"); }
  75. };
  76. // CHECK: *** Dumping AST Record Layout
  77. // CHECK: *** Dumping AST Record Layout
  78. // CHECK-NEXT: 0 | struct D
  79. // CHECK-NEXT: 0 | (D vftable pointer)
  80. // CHECK-NEXT: 4 | (D vbtable pointer)
  81. // CHECK-NEXT: 8 | struct B2 (virtual base)
  82. // CHECK-NEXT: 8 | int a
  83. // CHECK-NEXT: 12 | struct B0 (virtual base)
  84. // CHECK-NEXT: 12 | (B0 vftable pointer)
  85. // CHECK-NEXT: 16 | int a
  86. // CHECK-NEXT: | [sizeof=20, align=4
  87. // CHECK-NEXT: | nvsize=8, nvalign=4]
  88. // CHECK-X64: *** Dumping AST Record Layout
  89. // CHECK-X64: *** Dumping AST Record Layout
  90. // CHECK-X64-NEXT: 0 | struct D
  91. // CHECK-X64-NEXT: 0 | (D vftable pointer)
  92. // CHECK-X64-NEXT: 8 | (D vbtable pointer)
  93. // CHECK-X64-NEXT: 16 | struct B2 (virtual base)
  94. // CHECK-X64-NEXT: 16 | int a
  95. // CHECK-X64-NEXT: 24 | struct B0 (virtual base)
  96. // CHECK-X64-NEXT: 24 | (B0 vftable pointer)
  97. // CHECK-X64-NEXT: 32 | int a
  98. // CHECK-X64-NEXT: | [sizeof=40, align=8
  99. // CHECK-X64-NEXT: | nvsize=16, nvalign=8]
  100. struct E : B0, virtual B1 {
  101. virtual void f() { printf("E"); }
  102. virtual void g() { printf("E"); }
  103. };
  104. // CHECK: *** Dumping AST Record Layout
  105. // CHECK: *** Dumping AST Record Layout
  106. // CHECK-NEXT: 0 | struct E
  107. // CHECK-NEXT: 0 | struct B0 (primary base)
  108. // CHECK-NEXT: 0 | (B0 vftable pointer)
  109. // CHECK-NEXT: 4 | int a
  110. // CHECK-NEXT: 8 | (E vbtable pointer)
  111. // CHECK-NEXT: 12 | struct B1 (virtual base)
  112. // CHECK-NEXT: 12 | (B1 vftable pointer)
  113. // CHECK-NEXT: 16 | int a
  114. // CHECK-NEXT: | [sizeof=20, align=4
  115. // CHECK-NEXT: | nvsize=12, nvalign=4]
  116. // CHECK-X64: *** Dumping AST Record Layout
  117. // CHECK-X64: *** Dumping AST Record Layout
  118. // CHECK-X64-NEXT: 0 | struct E
  119. // CHECK-X64-NEXT: 0 | struct B0 (primary base)
  120. // CHECK-X64-NEXT: 0 | (B0 vftable pointer)
  121. // CHECK-X64-NEXT: 8 | int a
  122. // CHECK-X64-NEXT: 16 | (E vbtable pointer)
  123. // CHECK-X64-NEXT: 24 | struct B1 (virtual base)
  124. // CHECK-X64-NEXT: 24 | (B1 vftable pointer)
  125. // CHECK-X64-NEXT: 32 | int a
  126. // CHECK-X64-NEXT: | [sizeof=40, align=8
  127. // CHECK-X64-NEXT: | nvsize=24, nvalign=8]
  128. struct F : virtual B0, virtual B1 {
  129. };
  130. // CHECK: *** Dumping AST Record Layout
  131. // CHECK-NEXT: 0 | struct F
  132. // CHECK-NEXT: 0 | (F vbtable pointer)
  133. // CHECK-NEXT: 4 | struct B0 (virtual base)
  134. // CHECK-NEXT: 4 | (B0 vftable pointer)
  135. // CHECK-NEXT: 8 | int a
  136. // CHECK-NEXT: 12 | struct B1 (virtual base)
  137. // CHECK-NEXT: 12 | (B1 vftable pointer)
  138. // CHECK-NEXT: 16 | int a
  139. // CHECK-NEXT: | [sizeof=20, align=4
  140. // CHECK-NEXT: | nvsize=4, nvalign=4]
  141. // CHECK-X64: *** Dumping AST Record Layout
  142. // CHECK-X64-NEXT: 0 | struct F
  143. // CHECK-X64-NEXT: 0 | (F vbtable pointer)
  144. // CHECK-X64-NEXT: 8 | struct B0 (virtual base)
  145. // CHECK-X64-NEXT: 8 | (B0 vftable pointer)
  146. // CHECK-X64-NEXT: 16 | int a
  147. // CHECK-X64-NEXT: 24 | struct B1 (virtual base)
  148. // CHECK-X64-NEXT: 24 | (B1 vftable pointer)
  149. // CHECK-X64-NEXT: 32 | int a
  150. // CHECK-X64-NEXT: | [sizeof=40, align=8
  151. // CHECK-X64-NEXT: | nvsize=8, nvalign=8]
  152. struct AX : B0X, B1X { int a; AX() : a(0xf000000A) {} virtual void f() { printf("A"); } };
  153. // CHECK: *** Dumping AST Record Layout
  154. // CHECK: *** Dumping AST Record Layout
  155. // CHECK: *** Dumping AST Record Layout
  156. // CHECK-NEXT: 0 | struct AX
  157. // CHECK-NEXT: 0 | struct B1X (primary base)
  158. // CHECK-NEXT: 0 | (B1X vftable pointer)
  159. // CHECK-NEXT: 4 | int a
  160. // CHECK-NEXT: 8 | struct B0X (base)
  161. // CHECK-NEXT: 8 | int a
  162. // CHECK-NEXT: 12 | int a
  163. // CHECK-NEXT: | [sizeof=16, align=4
  164. // CHECK-NEXT: | nvsize=16, nvalign=4]
  165. // CHECK-X64: *** Dumping AST Record Layout
  166. // CHECK-X64: *** Dumping AST Record Layout
  167. // CHECK-X64: *** Dumping AST Record Layout
  168. // CHECK-X64-NEXT: 0 | struct AX
  169. // CHECK-X64-NEXT: 0 | struct B1X (primary base)
  170. // CHECK-X64-NEXT: 0 | (B1X vftable pointer)
  171. // CHECK-X64-NEXT: 8 | int a
  172. // CHECK-X64-NEXT: 16 | struct B0X (base)
  173. // CHECK-X64-NEXT: 16 | int a
  174. // CHECK-X64-NEXT: 20 | int a
  175. // CHECK-X64-NEXT: | [sizeof=24, align=8
  176. // CHECK-X64-NEXT: | nvsize=24, nvalign=8]
  177. struct BX : B0X, B1X { int a; BX() : a(0xf000000B) {} virtual void g() { printf("B"); } };
  178. // CHECK: *** Dumping AST Record Layout
  179. // CHECK-NEXT: 0 | struct BX
  180. // CHECK-NEXT: 0 | struct B1X (primary base)
  181. // CHECK-NEXT: 0 | (B1X vftable pointer)
  182. // CHECK-NEXT: 4 | int a
  183. // CHECK-NEXT: 8 | struct B0X (base)
  184. // CHECK-NEXT: 8 | int a
  185. // CHECK-NEXT: 12 | int a
  186. // CHECK-NEXT: | [sizeof=16, align=4
  187. // CHECK-NEXT: | nvsize=16, nvalign=4]
  188. // CHECK-X64: *** Dumping AST Record Layout
  189. // CHECK-X64-NEXT: 0 | struct BX
  190. // CHECK-X64-NEXT: 0 | struct B1X (primary base)
  191. // CHECK-X64-NEXT: 0 | (B1X vftable pointer)
  192. // CHECK-X64-NEXT: 8 | int a
  193. // CHECK-X64-NEXT: 16 | struct B0X (base)
  194. // CHECK-X64-NEXT: 16 | int a
  195. // CHECK-X64-NEXT: 20 | int a
  196. // CHECK-X64-NEXT: | [sizeof=24, align=8
  197. // CHECK-X64-NEXT: | nvsize=24, nvalign=8]
  198. struct CX : B0X, B2X { int a; CX() : a(0xf000000C) {} virtual void g() { printf("C"); } };
  199. // CHECK: *** Dumping AST Record Layout
  200. // CHECK: *** Dumping AST Record Layout
  201. // CHECK-NEXT: 0 | struct CX
  202. // CHECK-NEXT: 0 | (CX vftable pointer)
  203. // CHECK-NEXT: 4 | struct B0X (base)
  204. // CHECK-NEXT: 4 | int a
  205. // CHECK-NEXT: 8 | struct B2X (base)
  206. // CHECK-NEXT: 8 | (B2X vbtable pointer)
  207. // CHECK-NEXT: 12 | int a
  208. // CHECK-NEXT: 16 | int a
  209. // CHECK-NEXT: 20 | struct B1X (virtual base)
  210. // CHECK-NEXT: 20 | (B1X vftable pointer)
  211. // CHECK-NEXT: 24 | int a
  212. // CHECK-NEXT: | [sizeof=28, align=4
  213. // CHECK-NEXT: | nvsize=20, nvalign=4]
  214. // CHECK-X64: *** Dumping AST Record Layout
  215. // CHECK-X64: *** Dumping AST Record Layout
  216. // CHECK-X64-NEXT: 0 | struct CX
  217. // CHECK-X64-NEXT: 0 | (CX vftable pointer)
  218. // CHECK-X64-NEXT: 8 | struct B0X (base)
  219. // CHECK-X64-NEXT: 8 | int a
  220. // CHECK-X64-NEXT: 16 | struct B2X (base)
  221. // CHECK-X64-NEXT: 16 | (B2X vbtable pointer)
  222. // CHECK-X64-NEXT: 24 | int a
  223. // CHECK-X64-NEXT: 32 | int a
  224. // CHECK-X64-NEXT: 40 | struct B1X (virtual base)
  225. // CHECK-X64-NEXT: 40 | (B1X vftable pointer)
  226. // CHECK-X64-NEXT: 48 | int a
  227. // CHECK-X64-NEXT: | [sizeof=56, align=8
  228. // CHECK-X64-NEXT: | nvsize=40, nvalign=8]
  229. struct DX : virtual B1X { int a; DX() : a(0xf000000D) {} virtual void f() { printf("D"); } };
  230. // CHECK: *** Dumping AST Record Layout
  231. // CHECK-NEXT: 0 | struct DX
  232. // CHECK-NEXT: 0 | (DX vbtable pointer)
  233. // CHECK-NEXT: 4 | int a
  234. // CHECK-NEXT: 8 | (vtordisp for vbase B1X)
  235. // CHECK-NEXT: 12 | struct B1X (virtual base)
  236. // CHECK-NEXT: 12 | (B1X vftable pointer)
  237. // CHECK-NEXT: 16 | int a
  238. // CHECK-NEXT: | [sizeof=20, align=4
  239. // CHECK-NEXT: | nvsize=8, nvalign=4]
  240. // CHECK-X64: *** Dumping AST Record Layout
  241. // CHECK-X64-NEXT: 0 | struct DX
  242. // CHECK-X64-NEXT: 0 | (DX vbtable pointer)
  243. // CHECK-X64-NEXT: 8 | int a
  244. // CHECK-X64-NEXT: 20 | (vtordisp for vbase B1X)
  245. // CHECK-X64-NEXT: 24 | struct B1X (virtual base)
  246. // CHECK-X64-NEXT: 24 | (B1X vftable pointer)
  247. // CHECK-X64-NEXT: 32 | int a
  248. // CHECK-X64-NEXT: | [sizeof=40, align=8
  249. // CHECK-X64-NEXT: | nvsize=16, nvalign=8]
  250. struct EX : virtual B1X { int a; EX() : a(0xf000000E) {} virtual void g() { printf("E"); } };
  251. // CHECK: *** Dumping AST Record Layout
  252. // CHECK-NEXT: 0 | struct EX
  253. // CHECK-NEXT: 0 | (EX vftable pointer)
  254. // CHECK-NEXT: 4 | (EX vbtable pointer)
  255. // CHECK-NEXT: 8 | int a
  256. // CHECK-NEXT: 12 | struct B1X (virtual base)
  257. // CHECK-NEXT: 12 | (B1X vftable pointer)
  258. // CHECK-NEXT: 16 | int a
  259. // CHECK-NEXT: | [sizeof=20, align=4
  260. // CHECK-NEXT: | nvsize=12, nvalign=4]
  261. // CHECK-X64: *** Dumping AST Record Layout
  262. // CHECK-X64-NEXT: 0 | struct EX
  263. // CHECK-X64-NEXT: 0 | (EX vftable pointer)
  264. // CHECK-X64-NEXT: 8 | (EX vbtable pointer)
  265. // CHECK-X64-NEXT: 16 | int a
  266. // CHECK-X64-NEXT: 24 | struct B1X (virtual base)
  267. // CHECK-X64-NEXT: 24 | (B1X vftable pointer)
  268. // CHECK-X64-NEXT: 32 | int a
  269. // CHECK-X64-NEXT: | [sizeof=40, align=8
  270. // CHECK-X64-NEXT: | nvsize=24, nvalign=8]
  271. struct FX : virtual B1X { int a; FX() : a(0xf000000F) {} };
  272. // CHECK: *** Dumping AST Record Layout
  273. // CHECK-NEXT: 0 | struct FX
  274. // CHECK-NEXT: 0 | (FX vbtable pointer)
  275. // CHECK-NEXT: 4 | int a
  276. // CHECK-NEXT: 8 | struct B1X (virtual base)
  277. // CHECK-NEXT: 8 | (B1X vftable pointer)
  278. // CHECK-NEXT: 12 | int a
  279. // CHECK-NEXT: | [sizeof=16, align=4
  280. // CHECK-NEXT: | nvsize=8, nvalign=4]
  281. // CHECK-X64: *** Dumping AST Record Layout
  282. // CHECK-X64-NEXT: 0 | struct FX
  283. // CHECK-X64-NEXT: 0 | (FX vbtable pointer)
  284. // CHECK-X64-NEXT: 8 | int a
  285. // CHECK-X64-NEXT: 16 | struct B1X (virtual base)
  286. // CHECK-X64-NEXT: 16 | (B1X vftable pointer)
  287. // CHECK-X64-NEXT: 24 | int a
  288. // CHECK-X64-NEXT: | [sizeof=32, align=8
  289. // CHECK-X64-NEXT: | nvsize=16, nvalign=8]
  290. int a[
  291. sizeof(A)+
  292. sizeof(B)+
  293. sizeof(C)+
  294. sizeof(D)+
  295. sizeof(E)+
  296. sizeof(F)+
  297. sizeof(AX)+
  298. sizeof(BX)+
  299. sizeof(CX)+
  300. sizeof(DX)+
  301. sizeof(EX)+
  302. sizeof(FX)];