sanitize_test.go 43 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139
  1. // Copyright 2021 Google Inc. All rights reserved.
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain a copy of the License at
  6. //
  7. // http://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS,
  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. // See the License for the specific language governing permissions and
  13. // limitations under the License.
  14. package cc
  15. import (
  16. "fmt"
  17. "runtime"
  18. "strings"
  19. "testing"
  20. "android/soong/android"
  21. "github.com/google/blueprint"
  22. )
  23. var prepareForAsanTest = android.FixtureAddFile("asan/Android.bp", []byte(`
  24. cc_library_shared {
  25. name: "libclang_rt.asan",
  26. host_supported: true,
  27. }
  28. cc_library_static {
  29. name: "libclang_rt.asan.static",
  30. host_supported: true,
  31. }
  32. cc_library_static {
  33. name: "libclang_rt.asan_cxx.static",
  34. host_supported: true,
  35. }
  36. `))
  37. var prepareForTsanTest = android.FixtureAddFile("tsan/Android.bp", []byte(`
  38. cc_library_shared {
  39. name: "libclang_rt.tsan",
  40. host_supported: true,
  41. }
  42. `))
  43. type providerInterface interface {
  44. ModuleProvider(blueprint.Module, blueprint.ProviderKey) interface{}
  45. }
  46. // expectSharedLinkDep verifies that the from module links against the to module as a
  47. // shared library.
  48. func expectSharedLinkDep(t *testing.T, ctx providerInterface, from, to android.TestingModule) {
  49. t.Helper()
  50. fromLink := from.Description("link")
  51. toInfo := ctx.ModuleProvider(to.Module(), SharedLibraryInfoProvider).(SharedLibraryInfo)
  52. if g, w := fromLink.OrderOnly.Strings(), toInfo.SharedLibrary.RelativeToTop().String(); !android.InList(w, g) {
  53. t.Errorf("%s should link against %s, expected %q, got %q",
  54. from.Module(), to.Module(), w, g)
  55. }
  56. }
  57. // expectNoSharedLinkDep verifies that the from module links against the to module as a
  58. // shared library.
  59. func expectNoSharedLinkDep(t *testing.T, ctx providerInterface, from, to android.TestingModule) {
  60. t.Helper()
  61. fromLink := from.Description("link")
  62. toInfo := ctx.ModuleProvider(to.Module(), SharedLibraryInfoProvider).(SharedLibraryInfo)
  63. if g, w := fromLink.OrderOnly.Strings(), toInfo.SharedLibrary.RelativeToTop().String(); android.InList(w, g) {
  64. t.Errorf("%s should not link against %s, expected %q, got %q",
  65. from.Module(), to.Module(), w, g)
  66. }
  67. }
  68. // expectStaticLinkDep verifies that the from module links against the to module as a
  69. // static library.
  70. func expectStaticLinkDep(t *testing.T, ctx providerInterface, from, to android.TestingModule) {
  71. t.Helper()
  72. fromLink := from.Description("link")
  73. toInfo := ctx.ModuleProvider(to.Module(), StaticLibraryInfoProvider).(StaticLibraryInfo)
  74. if g, w := fromLink.Implicits.Strings(), toInfo.StaticLibrary.RelativeToTop().String(); !android.InList(w, g) {
  75. t.Errorf("%s should link against %s, expected %q, got %q",
  76. from.Module(), to.Module(), w, g)
  77. }
  78. }
  79. // expectNoStaticLinkDep verifies that the from module links against the to module as a
  80. // static library.
  81. func expectNoStaticLinkDep(t *testing.T, ctx providerInterface, from, to android.TestingModule) {
  82. t.Helper()
  83. fromLink := from.Description("link")
  84. toInfo := ctx.ModuleProvider(to.Module(), StaticLibraryInfoProvider).(StaticLibraryInfo)
  85. if g, w := fromLink.Implicits.Strings(), toInfo.StaticLibrary.RelativeToTop().String(); android.InList(w, g) {
  86. t.Errorf("%s should not link against %s, expected %q, got %q",
  87. from.Module(), to.Module(), w, g)
  88. }
  89. }
  90. // expectInstallDep verifies that the install rule of the from module depends on the
  91. // install rule of the to module.
  92. func expectInstallDep(t *testing.T, from, to android.TestingModule) {
  93. t.Helper()
  94. fromInstalled := from.Description("install")
  95. toInstalled := to.Description("install")
  96. // combine implicits and order-only dependencies, host uses implicit but device uses
  97. // order-only.
  98. got := append(fromInstalled.Implicits.Strings(), fromInstalled.OrderOnly.Strings()...)
  99. want := toInstalled.Output.String()
  100. if !android.InList(want, got) {
  101. t.Errorf("%s installation should depend on %s, expected %q, got %q",
  102. from.Module(), to.Module(), want, got)
  103. }
  104. }
  105. type expectedRuntimeLinkage int
  106. const (
  107. RUNTIME_LINKAGE_NONE = expectedRuntimeLinkage(0)
  108. RUNTIME_LINKAGE_SHARED = iota
  109. )
  110. func TestAsan(t *testing.T) {
  111. t.Parallel()
  112. bp := `
  113. cc_binary {
  114. name: "bin_with_asan",
  115. host_supported: true,
  116. shared_libs: [
  117. "libshared",
  118. "libasan",
  119. ],
  120. static_libs: [
  121. "libstatic",
  122. "libnoasan",
  123. "libstatic_asan",
  124. ],
  125. sanitize: {
  126. address: true,
  127. }
  128. }
  129. cc_binary {
  130. name: "bin_no_asan",
  131. host_supported: true,
  132. shared_libs: [
  133. "libshared",
  134. "libasan",
  135. ],
  136. static_libs: [
  137. "libstatic",
  138. "libnoasan",
  139. "libstatic_asan",
  140. ],
  141. }
  142. cc_library_shared {
  143. name: "libshared",
  144. host_supported: true,
  145. shared_libs: ["libtransitive"],
  146. }
  147. cc_library_shared {
  148. name: "libasan",
  149. host_supported: true,
  150. shared_libs: ["libtransitive"],
  151. sanitize: {
  152. address: true,
  153. }
  154. }
  155. cc_library_shared {
  156. name: "libtransitive",
  157. host_supported: true,
  158. }
  159. cc_library_static {
  160. name: "libstatic",
  161. host_supported: true,
  162. }
  163. cc_library_static {
  164. name: "libnoasan",
  165. host_supported: true,
  166. sanitize: {
  167. address: false,
  168. }
  169. }
  170. cc_library_static {
  171. name: "libstatic_asan",
  172. host_supported: true,
  173. sanitize: {
  174. address: true,
  175. }
  176. }
  177. `
  178. preparer := android.GroupFixturePreparers(
  179. prepareForCcTest,
  180. prepareForAsanTest,
  181. )
  182. buildOS := preparer.RunTestWithBp(t, bp).Config.BuildOSTarget.String()
  183. check := func(t *testing.T, variant string, runtimeLinkage expectedRuntimeLinkage, preparer android.FixturePreparer) {
  184. result := preparer.RunTestWithBp(t, bp)
  185. ctx := result.TestContext
  186. asanVariant := variant + "_asan"
  187. sharedVariant := variant + "_shared"
  188. sharedAsanVariant := sharedVariant + "_asan"
  189. staticVariant := variant + "_static"
  190. staticAsanVariant := staticVariant + "_asan"
  191. // The binaries, one with asan and one without
  192. binWithAsan := result.ModuleForTests("bin_with_asan", asanVariant)
  193. binNoAsan := result.ModuleForTests("bin_no_asan", variant)
  194. // Shared libraries that don't request asan
  195. libShared := result.ModuleForTests("libshared", sharedVariant)
  196. libTransitive := result.ModuleForTests("libtransitive", sharedVariant)
  197. // Shared library that requests asan
  198. libAsan := result.ModuleForTests("libasan", sharedAsanVariant)
  199. // Static library that uses an asan variant for bin_with_asan and a non-asan variant
  200. // for bin_no_asan.
  201. libStaticAsanVariant := result.ModuleForTests("libstatic", staticAsanVariant)
  202. libStaticNoAsanVariant := result.ModuleForTests("libstatic", staticVariant)
  203. // Static library that never uses asan.
  204. libNoAsan := result.ModuleForTests("libnoasan", staticVariant)
  205. // Static library that specifies asan
  206. libStaticAsan := result.ModuleForTests("libstatic_asan", staticAsanVariant)
  207. libStaticAsanNoAsanVariant := result.ModuleForTests("libstatic_asan", staticVariant)
  208. libAsanSharedRuntime := result.ModuleForTests("libclang_rt.asan", sharedVariant)
  209. expectSharedLinkDep(t, ctx, binWithAsan, libShared)
  210. expectSharedLinkDep(t, ctx, binWithAsan, libAsan)
  211. expectSharedLinkDep(t, ctx, libShared, libTransitive)
  212. expectSharedLinkDep(t, ctx, libAsan, libTransitive)
  213. expectStaticLinkDep(t, ctx, binWithAsan, libStaticAsanVariant)
  214. expectStaticLinkDep(t, ctx, binWithAsan, libNoAsan)
  215. expectStaticLinkDep(t, ctx, binWithAsan, libStaticAsan)
  216. expectInstallDep(t, binWithAsan, libShared)
  217. expectInstallDep(t, binWithAsan, libAsan)
  218. expectInstallDep(t, binWithAsan, libTransitive)
  219. expectInstallDep(t, libShared, libTransitive)
  220. expectInstallDep(t, libAsan, libTransitive)
  221. expectSharedLinkDep(t, ctx, binNoAsan, libShared)
  222. expectSharedLinkDep(t, ctx, binNoAsan, libAsan)
  223. expectSharedLinkDep(t, ctx, libShared, libTransitive)
  224. expectSharedLinkDep(t, ctx, libAsan, libTransitive)
  225. expectStaticLinkDep(t, ctx, binNoAsan, libStaticNoAsanVariant)
  226. expectStaticLinkDep(t, ctx, binNoAsan, libNoAsan)
  227. expectStaticLinkDep(t, ctx, binNoAsan, libStaticAsanNoAsanVariant)
  228. expectInstallDep(t, binNoAsan, libShared)
  229. expectInstallDep(t, binNoAsan, libAsan)
  230. expectInstallDep(t, binNoAsan, libTransitive)
  231. expectInstallDep(t, libShared, libTransitive)
  232. expectInstallDep(t, libAsan, libTransitive)
  233. if runtimeLinkage == RUNTIME_LINKAGE_SHARED {
  234. expectSharedLinkDep(t, ctx, binWithAsan, libAsanSharedRuntime)
  235. expectNoSharedLinkDep(t, ctx, binNoAsan, libAsanSharedRuntime)
  236. expectSharedLinkDep(t, ctx, libAsan, libAsanSharedRuntime)
  237. expectNoSharedLinkDep(t, ctx, libShared, libAsanSharedRuntime)
  238. expectNoSharedLinkDep(t, ctx, libTransitive, libAsanSharedRuntime)
  239. } else {
  240. expectNoSharedLinkDep(t, ctx, binWithAsan, libAsanSharedRuntime)
  241. expectNoSharedLinkDep(t, ctx, binNoAsan, libAsanSharedRuntime)
  242. expectNoSharedLinkDep(t, ctx, libAsan, libAsanSharedRuntime)
  243. expectNoSharedLinkDep(t, ctx, libShared, libAsanSharedRuntime)
  244. expectNoSharedLinkDep(t, ctx, libTransitive, libAsanSharedRuntime)
  245. }
  246. }
  247. t.Run("host", func(t *testing.T) { check(t, buildOS, RUNTIME_LINKAGE_NONE, preparer) })
  248. t.Run("device", func(t *testing.T) { check(t, "android_arm64_armv8-a", RUNTIME_LINKAGE_SHARED, preparer) })
  249. t.Run("host musl", func(t *testing.T) {
  250. check(t, "linux_musl_x86_64", RUNTIME_LINKAGE_SHARED,
  251. android.GroupFixturePreparers(preparer, PrepareForTestWithHostMusl))
  252. })
  253. }
  254. func TestTsan(t *testing.T) {
  255. t.Parallel()
  256. bp := `
  257. cc_binary {
  258. name: "bin_with_tsan",
  259. host_supported: true,
  260. shared_libs: [
  261. "libshared",
  262. "libtsan",
  263. ],
  264. sanitize: {
  265. thread: true,
  266. }
  267. }
  268. cc_binary {
  269. name: "bin_no_tsan",
  270. host_supported: true,
  271. shared_libs: [
  272. "libshared",
  273. "libtsan",
  274. ],
  275. }
  276. cc_library_shared {
  277. name: "libshared",
  278. host_supported: true,
  279. shared_libs: ["libtransitive"],
  280. }
  281. cc_library_shared {
  282. name: "libtsan",
  283. host_supported: true,
  284. shared_libs: ["libtransitive"],
  285. sanitize: {
  286. thread: true,
  287. }
  288. }
  289. cc_library_shared {
  290. name: "libtransitive",
  291. host_supported: true,
  292. }
  293. `
  294. preparer := android.GroupFixturePreparers(
  295. prepareForCcTest,
  296. prepareForTsanTest,
  297. )
  298. buildOS := preparer.RunTestWithBp(t, bp).Config.BuildOSTarget.String()
  299. check := func(t *testing.T, variant string, preparer android.FixturePreparer) {
  300. result := preparer.RunTestWithBp(t, bp)
  301. ctx := result.TestContext
  302. tsanVariant := variant + "_tsan"
  303. sharedVariant := variant + "_shared"
  304. sharedTsanVariant := sharedVariant + "_tsan"
  305. // The binaries, one with tsan and one without
  306. binWithTsan := result.ModuleForTests("bin_with_tsan", tsanVariant)
  307. binNoTsan := result.ModuleForTests("bin_no_tsan", variant)
  308. // Shared libraries that don't request tsan
  309. libShared := result.ModuleForTests("libshared", sharedVariant)
  310. libTransitive := result.ModuleForTests("libtransitive", sharedVariant)
  311. // Shared library that requests tsan
  312. libTsan := result.ModuleForTests("libtsan", sharedTsanVariant)
  313. expectSharedLinkDep(t, ctx, binWithTsan, libShared)
  314. expectSharedLinkDep(t, ctx, binWithTsan, libTsan)
  315. expectSharedLinkDep(t, ctx, libShared, libTransitive)
  316. expectSharedLinkDep(t, ctx, libTsan, libTransitive)
  317. expectSharedLinkDep(t, ctx, binNoTsan, libShared)
  318. expectSharedLinkDep(t, ctx, binNoTsan, libTsan)
  319. expectSharedLinkDep(t, ctx, libShared, libTransitive)
  320. expectSharedLinkDep(t, ctx, libTsan, libTransitive)
  321. }
  322. t.Run("host", func(t *testing.T) { check(t, buildOS, preparer) })
  323. t.Run("device", func(t *testing.T) { check(t, "android_arm64_armv8-a", preparer) })
  324. t.Run("host musl", func(t *testing.T) {
  325. check(t, "linux_musl_x86_64", android.GroupFixturePreparers(preparer, PrepareForTestWithHostMusl))
  326. })
  327. }
  328. func TestMiscUndefined(t *testing.T) {
  329. if runtime.GOOS != "linux" {
  330. t.Skip("requires linux")
  331. }
  332. t.Parallel()
  333. bp := `
  334. cc_binary {
  335. name: "bin_with_ubsan",
  336. srcs: ["src.cc"],
  337. host_supported: true,
  338. static_libs: [
  339. "libstatic",
  340. "libubsan",
  341. ],
  342. sanitize: {
  343. misc_undefined: ["integer"],
  344. }
  345. }
  346. cc_binary {
  347. name: "bin_no_ubsan",
  348. host_supported: true,
  349. srcs: ["src.cc"],
  350. static_libs: [
  351. "libstatic",
  352. "libubsan",
  353. ],
  354. }
  355. cc_library_static {
  356. name: "libstatic",
  357. host_supported: true,
  358. srcs: ["src.cc"],
  359. static_libs: ["libtransitive"],
  360. }
  361. cc_library_static {
  362. name: "libubsan",
  363. host_supported: true,
  364. srcs: ["src.cc"],
  365. whole_static_libs: ["libtransitive"],
  366. sanitize: {
  367. misc_undefined: ["integer"],
  368. }
  369. }
  370. cc_library_static {
  371. name: "libtransitive",
  372. host_supported: true,
  373. srcs: ["src.cc"],
  374. }
  375. `
  376. preparer := android.GroupFixturePreparers(
  377. prepareForCcTest,
  378. )
  379. buildOS := preparer.RunTestWithBp(t, bp).Config.BuildOSTarget.String()
  380. check := func(t *testing.T, variant string, preparer android.FixturePreparer) {
  381. result := preparer.RunTestWithBp(t, bp)
  382. ctx := result.TestContext
  383. staticVariant := variant + "_static"
  384. // The binaries, one with ubsan and one without
  385. binWithUbsan := result.ModuleForTests("bin_with_ubsan", variant)
  386. binNoUbsan := result.ModuleForTests("bin_no_ubsan", variant)
  387. // Static libraries that don't request ubsan
  388. libStatic := result.ModuleForTests("libstatic", staticVariant)
  389. libTransitive := result.ModuleForTests("libtransitive", staticVariant)
  390. libUbsan := result.ModuleForTests("libubsan", staticVariant)
  391. libUbsanMinimal := result.ModuleForTests("libclang_rt.ubsan_minimal", staticVariant)
  392. expectStaticLinkDep(t, ctx, binWithUbsan, libStatic)
  393. expectStaticLinkDep(t, ctx, binWithUbsan, libUbsan)
  394. expectStaticLinkDep(t, ctx, binWithUbsan, libUbsanMinimal)
  395. miscUndefinedSanFlag := "-fsanitize=integer"
  396. binWithUbsanCflags := binWithUbsan.Rule("cc").Args["cFlags"]
  397. if !strings.Contains(binWithUbsanCflags, miscUndefinedSanFlag) {
  398. t.Errorf("'bin_with_ubsan' Expected %q to be in flags %q, was not", miscUndefinedSanFlag, binWithUbsanCflags)
  399. }
  400. libStaticCflags := libStatic.Rule("cc").Args["cFlags"]
  401. if strings.Contains(libStaticCflags, miscUndefinedSanFlag) {
  402. t.Errorf("'libstatic' Expected %q to NOT be in flags %q, was", miscUndefinedSanFlag, binWithUbsanCflags)
  403. }
  404. libUbsanCflags := libUbsan.Rule("cc").Args["cFlags"]
  405. if !strings.Contains(libUbsanCflags, miscUndefinedSanFlag) {
  406. t.Errorf("'libubsan' Expected %q to be in flags %q, was not", miscUndefinedSanFlag, binWithUbsanCflags)
  407. }
  408. libTransitiveCflags := libTransitive.Rule("cc").Args["cFlags"]
  409. if strings.Contains(libTransitiveCflags, miscUndefinedSanFlag) {
  410. t.Errorf("'libtransitive': Expected %q to NOT be in flags %q, was", miscUndefinedSanFlag, binWithUbsanCflags)
  411. }
  412. expectStaticLinkDep(t, ctx, binNoUbsan, libStatic)
  413. expectStaticLinkDep(t, ctx, binNoUbsan, libUbsan)
  414. }
  415. t.Run("host", func(t *testing.T) { check(t, buildOS, preparer) })
  416. t.Run("device", func(t *testing.T) { check(t, "android_arm64_armv8-a", preparer) })
  417. t.Run("host musl", func(t *testing.T) {
  418. check(t, "linux_musl_x86_64", android.GroupFixturePreparers(preparer, PrepareForTestWithHostMusl))
  419. })
  420. }
  421. func TestFuzz(t *testing.T) {
  422. t.Parallel()
  423. bp := `
  424. cc_binary {
  425. name: "bin_with_fuzzer",
  426. host_supported: true,
  427. shared_libs: [
  428. "libshared",
  429. "libfuzzer",
  430. ],
  431. static_libs: [
  432. "libstatic",
  433. "libnofuzzer",
  434. "libstatic_fuzzer",
  435. ],
  436. sanitize: {
  437. fuzzer: true,
  438. }
  439. }
  440. cc_binary {
  441. name: "bin_no_fuzzer",
  442. host_supported: true,
  443. shared_libs: [
  444. "libshared",
  445. "libfuzzer",
  446. ],
  447. static_libs: [
  448. "libstatic",
  449. "libnofuzzer",
  450. "libstatic_fuzzer",
  451. ],
  452. }
  453. cc_library_shared {
  454. name: "libshared",
  455. host_supported: true,
  456. shared_libs: ["libtransitive"],
  457. }
  458. cc_library_shared {
  459. name: "libfuzzer",
  460. host_supported: true,
  461. shared_libs: ["libtransitive"],
  462. sanitize: {
  463. fuzzer: true,
  464. }
  465. }
  466. cc_library_shared {
  467. name: "libtransitive",
  468. host_supported: true,
  469. }
  470. cc_library_static {
  471. name: "libstatic",
  472. host_supported: true,
  473. }
  474. cc_library_static {
  475. name: "libnofuzzer",
  476. host_supported: true,
  477. sanitize: {
  478. fuzzer: false,
  479. }
  480. }
  481. cc_library_static {
  482. name: "libstatic_fuzzer",
  483. host_supported: true,
  484. }
  485. `
  486. result := android.GroupFixturePreparers(
  487. prepareForCcTest,
  488. ).RunTestWithBp(t, bp)
  489. check := func(t *testing.T, result *android.TestResult, variant string) {
  490. ctx := result.TestContext
  491. fuzzerVariant := variant + "_fuzzer"
  492. sharedVariant := variant + "_shared"
  493. sharedFuzzerVariant := sharedVariant + "_fuzzer"
  494. staticVariant := variant + "_static"
  495. staticFuzzerVariant := staticVariant + "_fuzzer"
  496. // The binaries, one with fuzzer and one without
  497. binWithFuzzer := result.ModuleForTests("bin_with_fuzzer", fuzzerVariant)
  498. binNoFuzzer := result.ModuleForTests("bin_no_fuzzer", variant)
  499. // Shared libraries that don't request fuzzer
  500. libShared := result.ModuleForTests("libshared", sharedVariant)
  501. libTransitive := result.ModuleForTests("libtransitive", sharedVariant)
  502. // Shared libraries that don't request fuzzer
  503. libSharedFuzzer := result.ModuleForTests("libshared", sharedFuzzerVariant)
  504. libTransitiveFuzzer := result.ModuleForTests("libtransitive", sharedFuzzerVariant)
  505. // Shared library that requests fuzzer
  506. libFuzzer := result.ModuleForTests("libfuzzer", sharedFuzzerVariant)
  507. // Static library that uses an fuzzer variant for bin_with_fuzzer and a non-fuzzer variant
  508. // for bin_no_fuzzer.
  509. libStaticFuzzerVariant := result.ModuleForTests("libstatic", staticFuzzerVariant)
  510. libStaticNoFuzzerVariant := result.ModuleForTests("libstatic", staticVariant)
  511. // Static library that never uses fuzzer.
  512. libNoFuzzer := result.ModuleForTests("libnofuzzer", staticVariant)
  513. // Static library that specifies fuzzer
  514. libStaticFuzzer := result.ModuleForTests("libstatic_fuzzer", staticFuzzerVariant)
  515. libStaticFuzzerNoFuzzerVariant := result.ModuleForTests("libstatic_fuzzer", staticVariant)
  516. expectSharedLinkDep(t, ctx, binWithFuzzer, libSharedFuzzer)
  517. expectSharedLinkDep(t, ctx, binWithFuzzer, libFuzzer)
  518. expectSharedLinkDep(t, ctx, libSharedFuzzer, libTransitiveFuzzer)
  519. expectSharedLinkDep(t, ctx, libFuzzer, libTransitiveFuzzer)
  520. expectStaticLinkDep(t, ctx, binWithFuzzer, libStaticFuzzerVariant)
  521. expectStaticLinkDep(t, ctx, binWithFuzzer, libNoFuzzer)
  522. expectStaticLinkDep(t, ctx, binWithFuzzer, libStaticFuzzer)
  523. expectSharedLinkDep(t, ctx, binNoFuzzer, libShared)
  524. expectSharedLinkDep(t, ctx, binNoFuzzer, libFuzzer)
  525. expectSharedLinkDep(t, ctx, libShared, libTransitive)
  526. expectSharedLinkDep(t, ctx, libFuzzer, libTransitiveFuzzer)
  527. expectStaticLinkDep(t, ctx, binNoFuzzer, libStaticNoFuzzerVariant)
  528. expectStaticLinkDep(t, ctx, binNoFuzzer, libNoFuzzer)
  529. expectStaticLinkDep(t, ctx, binNoFuzzer, libStaticFuzzerNoFuzzerVariant)
  530. }
  531. t.Run("device", func(t *testing.T) { check(t, result, "android_arm64_armv8-a") })
  532. }
  533. func TestUbsan(t *testing.T) {
  534. t.Parallel()
  535. if runtime.GOOS != "linux" {
  536. t.Skip("requires linux")
  537. }
  538. bp := `
  539. cc_binary {
  540. name: "bin_with_ubsan",
  541. host_supported: true,
  542. shared_libs: [
  543. "libshared",
  544. ],
  545. static_libs: [
  546. "libstatic",
  547. "libnoubsan",
  548. ],
  549. sanitize: {
  550. undefined: true,
  551. }
  552. }
  553. cc_binary {
  554. name: "bin_depends_ubsan_static",
  555. host_supported: true,
  556. shared_libs: [
  557. "libshared",
  558. ],
  559. static_libs: [
  560. "libstatic",
  561. "libubsan",
  562. "libnoubsan",
  563. ],
  564. }
  565. cc_binary {
  566. name: "bin_depends_ubsan_shared",
  567. host_supported: true,
  568. shared_libs: [
  569. "libsharedubsan",
  570. ],
  571. }
  572. cc_binary {
  573. name: "bin_no_ubsan",
  574. host_supported: true,
  575. shared_libs: [
  576. "libshared",
  577. ],
  578. static_libs: [
  579. "libstatic",
  580. "libnoubsan",
  581. ],
  582. }
  583. cc_library_shared {
  584. name: "libshared",
  585. host_supported: true,
  586. shared_libs: ["libtransitive"],
  587. }
  588. cc_library_shared {
  589. name: "libtransitive",
  590. host_supported: true,
  591. }
  592. cc_library_shared {
  593. name: "libsharedubsan",
  594. host_supported: true,
  595. sanitize: {
  596. undefined: true,
  597. }
  598. }
  599. cc_library_static {
  600. name: "libubsan",
  601. host_supported: true,
  602. sanitize: {
  603. undefined: true,
  604. }
  605. }
  606. cc_library_static {
  607. name: "libstatic",
  608. host_supported: true,
  609. }
  610. cc_library_static {
  611. name: "libnoubsan",
  612. host_supported: true,
  613. }
  614. `
  615. preparer := android.GroupFixturePreparers(
  616. prepareForCcTest,
  617. )
  618. buildOS := preparer.RunTestWithBp(t, bp).Config.BuildOSTarget.String()
  619. check := func(t *testing.T, variant string, preparer android.FixturePreparer) {
  620. result := preparer.RunTestWithBp(t, bp)
  621. staticVariant := variant + "_static"
  622. sharedVariant := variant + "_shared"
  623. minimalRuntime := result.ModuleForTests("libclang_rt.ubsan_minimal", staticVariant)
  624. // The binaries, one with ubsan and one without
  625. binWithUbsan := result.ModuleForTests("bin_with_ubsan", variant)
  626. binDependsUbsan := result.ModuleForTests("bin_depends_ubsan_static", variant)
  627. libSharedUbsan := result.ModuleForTests("libsharedubsan", sharedVariant)
  628. binDependsUbsanShared := result.ModuleForTests("bin_depends_ubsan_shared", variant)
  629. binNoUbsan := result.ModuleForTests("bin_no_ubsan", variant)
  630. android.AssertStringListContains(t, "missing libclang_rt.ubsan_minimal in bin_with_ubsan static libs",
  631. strings.Split(binWithUbsan.Rule("ld").Args["libFlags"], " "),
  632. minimalRuntime.OutputFiles(t, "")[0].String())
  633. android.AssertStringListContains(t, "missing libclang_rt.ubsan_minimal in bin_depends_ubsan_static static libs",
  634. strings.Split(binDependsUbsan.Rule("ld").Args["libFlags"], " "),
  635. minimalRuntime.OutputFiles(t, "")[0].String())
  636. android.AssertStringListContains(t, "missing libclang_rt.ubsan_minimal in libsharedubsan static libs",
  637. strings.Split(libSharedUbsan.Rule("ld").Args["libFlags"], " "),
  638. minimalRuntime.OutputFiles(t, "")[0].String())
  639. android.AssertStringListDoesNotContain(t, "unexpected libclang_rt.ubsan_minimal in bin_depends_ubsan_shared static libs",
  640. strings.Split(binDependsUbsanShared.Rule("ld").Args["libFlags"], " "),
  641. minimalRuntime.OutputFiles(t, "")[0].String())
  642. android.AssertStringListDoesNotContain(t, "unexpected libclang_rt.ubsan_minimal in bin_no_ubsan static libs",
  643. strings.Split(binNoUbsan.Rule("ld").Args["libFlags"], " "),
  644. minimalRuntime.OutputFiles(t, "")[0].String())
  645. android.AssertStringListContains(t, "missing -Wl,--exclude-libs for minimal runtime in bin_with_ubsan",
  646. strings.Split(binWithUbsan.Rule("ld").Args["ldFlags"], " "),
  647. "-Wl,--exclude-libs="+minimalRuntime.OutputFiles(t, "")[0].Base())
  648. android.AssertStringListContains(t, "missing -Wl,--exclude-libs for minimal runtime in bin_depends_ubsan_static static libs",
  649. strings.Split(binDependsUbsan.Rule("ld").Args["ldFlags"], " "),
  650. "-Wl,--exclude-libs="+minimalRuntime.OutputFiles(t, "")[0].Base())
  651. android.AssertStringListContains(t, "missing -Wl,--exclude-libs for minimal runtime in libsharedubsan static libs",
  652. strings.Split(libSharedUbsan.Rule("ld").Args["ldFlags"], " "),
  653. "-Wl,--exclude-libs="+minimalRuntime.OutputFiles(t, "")[0].Base())
  654. android.AssertStringListDoesNotContain(t, "unexpected -Wl,--exclude-libs for minimal runtime in bin_depends_ubsan_shared static libs",
  655. strings.Split(binDependsUbsanShared.Rule("ld").Args["ldFlags"], " "),
  656. "-Wl,--exclude-libs="+minimalRuntime.OutputFiles(t, "")[0].Base())
  657. android.AssertStringListDoesNotContain(t, "unexpected -Wl,--exclude-libs for minimal runtime in bin_no_ubsan static libs",
  658. strings.Split(binNoUbsan.Rule("ld").Args["ldFlags"], " "),
  659. "-Wl,--exclude-libs="+minimalRuntime.OutputFiles(t, "")[0].Base())
  660. }
  661. t.Run("host", func(t *testing.T) { check(t, buildOS, preparer) })
  662. t.Run("device", func(t *testing.T) { check(t, "android_arm64_armv8-a", preparer) })
  663. t.Run("host musl", func(t *testing.T) {
  664. check(t, "linux_musl_x86_64", android.GroupFixturePreparers(preparer, PrepareForTestWithHostMusl))
  665. })
  666. }
  667. type MemtagNoteType int
  668. const (
  669. None MemtagNoteType = iota + 1
  670. Sync
  671. Async
  672. )
  673. func (t MemtagNoteType) str() string {
  674. switch t {
  675. case None:
  676. return "none"
  677. case Sync:
  678. return "sync"
  679. case Async:
  680. return "async"
  681. default:
  682. panic("type_note_invalid")
  683. }
  684. }
  685. func checkHasMemtagNote(t *testing.T, m android.TestingModule, expected MemtagNoteType) {
  686. t.Helper()
  687. found := None
  688. ldFlags := m.Rule("ld").Args["ldFlags"]
  689. if strings.Contains(ldFlags, "-fsanitize-memtag-mode=async") {
  690. found = Async
  691. } else if strings.Contains(ldFlags, "-fsanitize-memtag-mode=sync") {
  692. found = Sync
  693. }
  694. if found != expected {
  695. t.Errorf("Wrong Memtag note in target %q: found %q, expected %q", m.Module().(*Module).Name(), found.str(), expected.str())
  696. }
  697. }
  698. var prepareForTestWithMemtagHeap = android.GroupFixturePreparers(
  699. android.FixtureModifyMockFS(func(fs android.MockFS) {
  700. templateBp := `
  701. cc_test {
  702. name: "unset_test_%[1]s",
  703. gtest: false,
  704. }
  705. cc_test {
  706. name: "no_memtag_test_%[1]s",
  707. gtest: false,
  708. sanitize: { memtag_heap: false },
  709. }
  710. cc_test {
  711. name: "set_memtag_test_%[1]s",
  712. gtest: false,
  713. sanitize: { memtag_heap: true },
  714. }
  715. cc_test {
  716. name: "set_memtag_set_async_test_%[1]s",
  717. gtest: false,
  718. sanitize: { memtag_heap: true, diag: { memtag_heap: false } },
  719. }
  720. cc_test {
  721. name: "set_memtag_set_sync_test_%[1]s",
  722. gtest: false,
  723. sanitize: { memtag_heap: true, diag: { memtag_heap: true } },
  724. }
  725. cc_test {
  726. name: "unset_memtag_set_sync_test_%[1]s",
  727. gtest: false,
  728. sanitize: { diag: { memtag_heap: true } },
  729. }
  730. cc_binary {
  731. name: "unset_binary_%[1]s",
  732. }
  733. cc_binary {
  734. name: "no_memtag_binary_%[1]s",
  735. sanitize: { memtag_heap: false },
  736. }
  737. cc_binary {
  738. name: "set_memtag_binary_%[1]s",
  739. sanitize: { memtag_heap: true },
  740. }
  741. cc_binary {
  742. name: "set_memtag_set_async_binary_%[1]s",
  743. sanitize: { memtag_heap: true, diag: { memtag_heap: false } },
  744. }
  745. cc_binary {
  746. name: "set_memtag_set_sync_binary_%[1]s",
  747. sanitize: { memtag_heap: true, diag: { memtag_heap: true } },
  748. }
  749. cc_binary {
  750. name: "unset_memtag_set_sync_binary_%[1]s",
  751. sanitize: { diag: { memtag_heap: true } },
  752. }
  753. `
  754. subdirNoOverrideBp := fmt.Sprintf(templateBp, "no_override")
  755. subdirOverrideDefaultDisableBp := fmt.Sprintf(templateBp, "override_default_disable")
  756. subdirSyncBp := fmt.Sprintf(templateBp, "override_default_sync")
  757. subdirAsyncBp := fmt.Sprintf(templateBp, "override_default_async")
  758. fs.Merge(android.MockFS{
  759. "subdir_no_override/Android.bp": []byte(subdirNoOverrideBp),
  760. "subdir_override_default_disable/Android.bp": []byte(subdirOverrideDefaultDisableBp),
  761. "subdir_sync/Android.bp": []byte(subdirSyncBp),
  762. "subdir_async/Android.bp": []byte(subdirAsyncBp),
  763. })
  764. }),
  765. android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
  766. variables.MemtagHeapExcludePaths = []string{"subdir_override_default_disable"}
  767. // "subdir_override_default_disable" is covered by both include and override_default_disable paths. override_default_disable wins.
  768. variables.MemtagHeapSyncIncludePaths = []string{"subdir_sync", "subdir_override_default_disable"}
  769. variables.MemtagHeapAsyncIncludePaths = []string{"subdir_async", "subdir_override_default_disable"}
  770. }),
  771. )
  772. func TestSanitizeMemtagHeap(t *testing.T) {
  773. t.Parallel()
  774. variant := "android_arm64_armv8-a"
  775. result := android.GroupFixturePreparers(
  776. prepareForCcTest,
  777. prepareForTestWithMemtagHeap,
  778. ).RunTest(t)
  779. ctx := result.TestContext
  780. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_no_override", variant), None)
  781. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_async", variant), None)
  782. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_disable", variant), None)
  783. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_sync", variant), None)
  784. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_no_override", variant), None)
  785. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_async", variant), None)
  786. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_disable", variant), None)
  787. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_sync", variant), None)
  788. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_no_override", variant), Async)
  789. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_async", variant), Async)
  790. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_disable", variant), Async)
  791. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_sync", variant), Sync)
  792. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_no_override", variant), Sync)
  793. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_async", variant), Sync)
  794. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_disable", variant), Sync)
  795. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_sync", variant), Sync)
  796. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_no_override", variant), Async)
  797. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_async", variant), Async)
  798. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_disable", variant), Async)
  799. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_sync", variant), Async)
  800. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_no_override", variant), Async)
  801. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_async", variant), Async)
  802. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_disable", variant), Async)
  803. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_sync", variant), Async)
  804. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_no_override", variant), Sync)
  805. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_async", variant), Sync)
  806. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_disable", variant), Sync)
  807. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_sync", variant), Sync)
  808. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_no_override", variant), Sync)
  809. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_async", variant), Sync)
  810. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_disable", variant), Sync)
  811. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_sync", variant), Sync)
  812. // should sanitize: { diag: { memtag: true } } result in Sync instead of None here?
  813. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_no_override", variant), None)
  814. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_async", variant), Sync)
  815. // should sanitize: { diag: { memtag: true } } result in Sync instead of None here?
  816. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_disable", variant), None)
  817. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_sync", variant), Sync)
  818. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_no_override", variant), Sync)
  819. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_async", variant), Sync)
  820. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_disable", variant), Sync)
  821. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_sync", variant), Sync)
  822. checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_no_override", variant), None)
  823. checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_async", variant), Async)
  824. checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_disable", variant), None)
  825. checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_sync", variant), Sync)
  826. checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_no_override", variant), Sync)
  827. checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_async", variant), Sync)
  828. checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_disable", variant), Sync)
  829. checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_sync", variant), Sync)
  830. }
  831. func TestSanitizeMemtagHeapWithSanitizeDevice(t *testing.T) {
  832. t.Parallel()
  833. variant := "android_arm64_armv8-a"
  834. result := android.GroupFixturePreparers(
  835. prepareForCcTest,
  836. prepareForTestWithMemtagHeap,
  837. android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
  838. variables.SanitizeDevice = []string{"memtag_heap"}
  839. }),
  840. ).RunTest(t)
  841. ctx := result.TestContext
  842. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_no_override", variant), None)
  843. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_async", variant), None)
  844. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_disable", variant), None)
  845. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_sync", variant), None)
  846. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_no_override", variant), None)
  847. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_async", variant), None)
  848. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_disable", variant), None)
  849. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_sync", variant), None)
  850. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_no_override", variant), Async)
  851. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_async", variant), Async)
  852. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_disable", variant), Async)
  853. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_sync", variant), Sync)
  854. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_no_override", variant), Sync)
  855. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_async", variant), Sync)
  856. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_disable", variant), Sync)
  857. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_sync", variant), Sync)
  858. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_no_override", variant), Async)
  859. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_async", variant), Async)
  860. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_disable", variant), Async)
  861. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_sync", variant), Async)
  862. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_no_override", variant), Async)
  863. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_async", variant), Async)
  864. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_disable", variant), Async)
  865. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_sync", variant), Async)
  866. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_no_override", variant), Sync)
  867. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_async", variant), Sync)
  868. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_disable", variant), Sync)
  869. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_sync", variant), Sync)
  870. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_no_override", variant), Sync)
  871. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_async", variant), Sync)
  872. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_disable", variant), Sync)
  873. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_sync", variant), Sync)
  874. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_no_override", variant), Sync)
  875. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_async", variant), Sync)
  876. // should sanitize: { diag: { memtag: true } } result in Sync instead of None here?
  877. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_disable", variant), None)
  878. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_sync", variant), Sync)
  879. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_no_override", variant), Sync)
  880. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_async", variant), Sync)
  881. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_disable", variant), Sync)
  882. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_sync", variant), Sync)
  883. checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_no_override", variant), Async)
  884. checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_async", variant), Async)
  885. checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_disable", variant), None)
  886. checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_sync", variant), Sync)
  887. checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_no_override", variant), Sync)
  888. checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_async", variant), Sync)
  889. checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_disable", variant), Sync)
  890. checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_sync", variant), Sync)
  891. }
  892. func TestSanitizeMemtagHeapWithSanitizeDeviceDiag(t *testing.T) {
  893. t.Parallel()
  894. variant := "android_arm64_armv8-a"
  895. result := android.GroupFixturePreparers(
  896. prepareForCcTest,
  897. prepareForTestWithMemtagHeap,
  898. android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
  899. variables.SanitizeDevice = []string{"memtag_heap"}
  900. variables.SanitizeDeviceDiag = []string{"memtag_heap"}
  901. }),
  902. ).RunTest(t)
  903. ctx := result.TestContext
  904. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_no_override", variant), None)
  905. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_async", variant), None)
  906. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_disable", variant), None)
  907. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_sync", variant), None)
  908. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_no_override", variant), None)
  909. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_async", variant), None)
  910. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_disable", variant), None)
  911. checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_sync", variant), None)
  912. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_no_override", variant), Sync)
  913. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_async", variant), Sync)
  914. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_disable", variant), Sync)
  915. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_sync", variant), Sync)
  916. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_no_override", variant), Sync)
  917. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_async", variant), Sync)
  918. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_disable", variant), Sync)
  919. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_sync", variant), Sync)
  920. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_no_override", variant), Async)
  921. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_async", variant), Async)
  922. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_disable", variant), Async)
  923. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_sync", variant), Async)
  924. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_no_override", variant), Async)
  925. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_async", variant), Async)
  926. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_disable", variant), Async)
  927. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_sync", variant), Async)
  928. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_no_override", variant), Sync)
  929. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_async", variant), Sync)
  930. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_disable", variant), Sync)
  931. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_sync", variant), Sync)
  932. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_no_override", variant), Sync)
  933. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_async", variant), Sync)
  934. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_disable", variant), Sync)
  935. checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_sync", variant), Sync)
  936. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_no_override", variant), Sync)
  937. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_async", variant), Sync)
  938. // should sanitize: { diag: { memtag: true } } result in Sync instead of None here?
  939. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_disable", variant), None)
  940. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_sync", variant), Sync)
  941. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_no_override", variant), Sync)
  942. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_async", variant), Sync)
  943. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_disable", variant), Sync)
  944. checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_sync", variant), Sync)
  945. checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_no_override", variant), Sync)
  946. checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_async", variant), Sync)
  947. checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_disable", variant), None)
  948. checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_sync", variant), Sync)
  949. checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_no_override", variant), Sync)
  950. checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_async", variant), Sync)
  951. checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_disable", variant), Sync)
  952. checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_sync", variant), Sync)
  953. }