msan_test.cc revision 47177efc15d2a75c7c85ba31aa61e41e7b47b5a3
19e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek//===-- msan_test.cc ------------------------------------------------------===// 29e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek// 39e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek// The LLVM Compiler Infrastructure 49e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek// 59e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek// This file is distributed under the University of Illinois Open Source 69e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek// License. See LICENSE.TXT for details. 79e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek// 89e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek//===----------------------------------------------------------------------===// 99e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek// 109e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek// This file is a part of MemorySanitizer. 119e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek// 129e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek// MemorySanitizer unit tests. 139e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek//===----------------------------------------------------------------------===// 149e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek 159e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek#ifndef MSAN_EXTERNAL_TEST_CONFIG 165a4f98ff943e6a501b0fe47ade007c9bbf96cb88Argyrios Kyrtzidis#include "msan_test_config.h" 175a4f98ff943e6a501b0fe47ade007c9bbf96cb88Argyrios Kyrtzidis#endif // MSAN_EXTERNAL_TEST_CONFIG 189e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek 199ff2b13aee0f89d23ef4820218f9b88bb5e5c1c1Ken Dyck#include "sanitizer/msan_interface.h" 20993f1c72913417be7c534ec7a634363cdfc84fa5Ted Kremenek#include "msandr_test_so.h" 214c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek 22d47d3b0cfeb7e8564ff77f48130fe63282b6d127Chris Lattner#include <inttypes.h> 239b663716449b618ba0390b1dbebc54fa8e971124Ted Kremenek#include <stdlib.h> 249c1845dbed9817520f5a7db8bd80a560c6c6ae6bArgyrios Kyrtzidis#include <stdarg.h> 259e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek#include <stdio.h> 269e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek#include <assert.h> 279e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek#include <wchar.h> 285e2d2c2ee3cf410643e0f9a5701708e51409d973Benjamin Kramer#include <math.h> 295e2d2c2ee3cf410643e0f9a5701708e51409d973Benjamin Kramer 305e2d2c2ee3cf410643e0f9a5701708e51409d973Benjamin Kramer#include <arpa/inet.h> 319e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek#include <dlfcn.h> 329e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek#include <grp.h> 331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump#include <unistd.h> 34d17da2b99f323fa91b01e1dd119cc32e0ee8197dTed Kremenek#include <link.h> 3567d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek#include <limits.h> 365a4f98ff943e6a501b0fe47ade007c9bbf96cb88Argyrios Kyrtzidis#include <sys/time.h> 379ef6537a894c33003359b1f9b9676e9178e028b7Ted Kremenek#include <poll.h> 385a4f98ff943e6a501b0fe47ade007c9bbf96cb88Argyrios Kyrtzidis#include <sys/types.h> 395a4f98ff943e6a501b0fe47ade007c9bbf96cb88Argyrios Kyrtzidis#include <sys/stat.h> 405a4f98ff943e6a501b0fe47ade007c9bbf96cb88Argyrios Kyrtzidis#include <fcntl.h> 41c8413fd03f73084a5c93028f8b4db619fc388087Ted Kremenek#include <sys/resource.h> 424240096011a187807058f887eb81df750ffa17feTed Kremenek#include <sys/ioctl.h> 43dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek#include <sys/sysinfo.h> 441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump#include <sys/utsname.h> 45e888233f6b115d3b0dd73bcb5f35e93794408542Zhongxing Xu#include <sys/mman.h> 46e888233f6b115d3b0dd73bcb5f35e93794408542Zhongxing Xu#include <sys/vfs.h> 47e888233f6b115d3b0dd73bcb5f35e93794408542Zhongxing Xu#include <dirent.h> 48e888233f6b115d3b0dd73bcb5f35e93794408542Zhongxing Xu#include <pwd.h> 49e888233f6b115d3b0dd73bcb5f35e93794408542Zhongxing Xu#include <sys/socket.h> 50e888233f6b115d3b0dd73bcb5f35e93794408542Zhongxing Xu#include <netdb.h> 51e3273e78da4716f9c999ae207f6898f376a6e1a4Zhongxing Xu 52e888233f6b115d3b0dd73bcb5f35e93794408542Zhongxing Xu#if defined(__i386__) || defined(__x86_64__) 53e888233f6b115d3b0dd73bcb5f35e93794408542Zhongxing Xu# include <emmintrin.h> 54e888233f6b115d3b0dd73bcb5f35e93794408542Zhongxing Xu# define MSAN_HAS_M128 1 55e3273e78da4716f9c999ae207f6898f376a6e1a4Zhongxing Xu#else 56e888233f6b115d3b0dd73bcb5f35e93794408542Zhongxing Xu# define MSAN_HAS_M128 0 57e888233f6b115d3b0dd73bcb5f35e93794408542Zhongxing Xu#endif 58e3273e78da4716f9c999ae207f6898f376a6e1a4Zhongxing Xu 59e888233f6b115d3b0dd73bcb5f35e93794408542Zhongxing Xutypedef unsigned char U1; 60e888233f6b115d3b0dd73bcb5f35e93794408542Zhongxing Xutypedef unsigned short U2; // NOLINT 6119e1f0ba5cec738ce6cebe3fe0e1edc782206494Ted Kremenektypedef unsigned int U4; 6219e1f0ba5cec738ce6cebe3fe0e1edc782206494Ted Kremenektypedef unsigned long long U8; // NOLINT 6319e1f0ba5cec738ce6cebe3fe0e1edc782206494Ted Kremenektypedef signed char S1; 641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumptypedef signed short S2; // NOLINT 659e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenektypedef signed int S4; 669e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenektypedef signed long long S8; // NOLINT 674240096011a187807058f887eb81df750ffa17feTed Kremenek#define NOINLINE __attribute__((noinline)) 689e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek#define INLINE __attribute__((always_inline)) 6967d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek 7067d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenekstatic bool TrackingOrigins() { 71dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek S8 x; 7267d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek __msan_set_origin(&x, sizeof(x), 0x1234); 7367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek U4 origin = __msan_get_origin(&x); 7467d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek __msan_set_origin(&x, sizeof(x), 0); 752b87ae45e129b941d0a4d221c9d4842385a119bdTed Kremenek return origin == 0x1234; 76dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek} 77eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks 78eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks#define EXPECT_UMR(action) \ 79eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks do { \ 80eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks __msan_set_expect_umr(1); \ 81eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks action; \ 82eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks __msan_set_expect_umr(0); \ 83eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks } while (0) 84dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek 85eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks#define EXPECT_UMR_O(action, origin) \ 8667d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek do { \ 8767d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek __msan_set_expect_umr(1); \ 8867d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek action; \ 899697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek __msan_set_expect_umr(0); \ 9067d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek if (TrackingOrigins()) \ 9167d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_EQ(origin, __msan_get_umr_origin()); \ 9267d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek } while (0) 9367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek 949697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek#define EXPECT_UMR_S(action, stack_origin) \ 959697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek do { \ 96de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek __msan_set_expect_umr(1); \ 9767d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek action; \ 984c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek __msan_set_expect_umr(0); \ 9967d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek U4 id = __msan_get_umr_origin(); \ 10067d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek const char *str = __msan_get_origin_descr_if_stack(id); \ 10167d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek if (!str || strcmp(str, stack_origin)) { \ 10267d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek fprintf(stderr, "EXPECT_POISONED_S: id=%u %s, %s", \ 10367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek id, stack_origin, str); \ 10467d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_EQ(1, 0); \ 1054fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu } \ 10602fe28c8a6da29d4ad88d0900c133dcf22d24a75Zhongxing Xu } while (0) 1074fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu 108096aef9597b263b4cd6a0feaacf9e7214fa9c75aJordy Rose#define EXPECT_POISONED(x) ExpectPoisoned(x) 109096aef9597b263b4cd6a0feaacf9e7214fa9c75aJordy Rose 11067d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenektemplate<typename T> 11167d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenekvoid ExpectPoisoned(const T& t) { 1129e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek EXPECT_NE(-1, __msan_test_shadow((void*)&t, sizeof(t))); 1139e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek} 1141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1159e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek#define EXPECT_POISONED_O(x, origin) \ 1169e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek ExpectPoisonedWithOrigin(x, origin) 1179e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek 1189e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenektemplate<typename T> 1199e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenekvoid ExpectPoisonedWithOrigin(const T& t, unsigned origin) { 120a6275a534da701f37d19a068e6361e5f10f983a1Ted Kremenek EXPECT_NE(-1, __msan_test_shadow((void*)&t, sizeof(t))); 1211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (TrackingOrigins()) 1229e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek EXPECT_EQ(origin, __msan_get_origin((void*)&t)); 123a43484afda4c4fb4b23a53a2dc91d985d39dc2c4Ted Kremenek} 124a43484afda4c4fb4b23a53a2dc91d985d39dc2c4Ted Kremenek 125a43484afda4c4fb4b23a53a2dc91d985d39dc2c4Ted Kremenek#define EXPECT_POISONED_S(x, stack_origin) \ 1269e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek ExpectPoisonedWithStackOrigin(x, stack_origin) 1271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 128bb7c96f290453104ec35ca17111a5165f68a4697Ted Kremenektemplate<typename T> 1291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid ExpectPoisonedWithStackOrigin(const T& t, const char *stack_origin) { 130adca27102ff733c7d42fcbbc2c7e134a7fc026f9Zhongxing Xu EXPECT_NE(-1, __msan_test_shadow((void*)&t, sizeof(t))); 131adca27102ff733c7d42fcbbc2c7e134a7fc026f9Zhongxing Xu U4 id = __msan_get_origin((void*)&t); 132479529e679957fbb92b56e116e3c86734429331eZhongxing Xu const char *str = __msan_get_origin_descr_if_stack(id); 1331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!str || strcmp(str, stack_origin)) { 1341508636e99faddf569a57fce82c0fb3aa2124396Ted Kremenek fprintf(stderr, "EXPECT_POISONED_S: id=%u %s, %s", 1351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump id, stack_origin, str); 136de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek EXPECT_EQ(1, 0); 137de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek } 138de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek} 139de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek 140de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek#define EXPECT_NOT_POISONED(x) ExpectNotPoisoned(x) 141b21ff77c8126ea628b66d2ffb931fdaa7884f5d2Zhongxing Xu 142e888233f6b115d3b0dd73bcb5f35e93794408542Zhongxing Xutemplate<typename T> 143e888233f6b115d3b0dd73bcb5f35e93794408542Zhongxing Xuvoid ExpectNotPoisoned(const T& t) { 144e888233f6b115d3b0dd73bcb5f35e93794408542Zhongxing Xu EXPECT_EQ(-1, __msan_test_shadow((void*)&t, sizeof(t))); 1459c378f705405d37f49795d5e915989de774fe11fTed Kremenek} 1467f39d29cb69e7488f994870800d548008e50e1cbTed Kremenek 1478800ad4eaa1621f6d23c8264971063b9f8da6a2eTed Kremenekstatic U8 poisoned_array[100]; 1481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumptemplate<class T> 1491eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpT *GetPoisoned(int i = 0, T val = 0) { 1501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump T *res = (T*)&poisoned_array[i]; 151ed65d3d97132fbcdd124aef4d2478e348dfbd36bTed Kremenek *res = val; 1521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump __msan_poison(&poisoned_array[i], sizeof(T)); 153f0f0605c87739c906861f73d4287798a4969b1e0Zhongxing Xu return res; 154b21ff77c8126ea628b66d2ffb931fdaa7884f5d2Zhongxing Xu} 1559e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek 1569e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenektemplate<class T> 1571eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpT *GetPoisonedO(int i, U4 origin, T val = 0) { 158eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks T *res = (T*)&poisoned_array[i]; 1599e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek *res = val; 1609e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek __msan_poison(&poisoned_array[i], sizeof(T)); 161a43484afda4c4fb4b23a53a2dc91d985d39dc2c4Ted Kremenek __msan_set_origin(&poisoned_array[i], sizeof(T), origin); 16267d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek return res; 16367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek} 164a43484afda4c4fb4b23a53a2dc91d985d39dc2c4Ted Kremenek 165a43484afda4c4fb4b23a53a2dc91d985d39dc2c4Ted Kremenek// This function returns its parameter but in such a way that compiler 16667d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek// can not prove it. 16767d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenektemplate<class T> 16867d1287035767f4f6c8ca0c2bb755990012a44caTed KremenekNOINLINE 16967d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenekstatic T Ident(T t) { 17067d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek volatile T ret = t; 17167d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek return ret; 1721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump} 17367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek 17467d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenektemplate<class T> NOINLINE T ReturnPoisoned() { return *GetPoisoned<T>(); } 17567d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek 17667d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenekstatic volatile int g_one = 1; 17767d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenekstatic volatile int g_zero = 0; 17867d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenekstatic volatile int g_0 = 0; 17967d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenekstatic volatile int g_1 = 1; 18067d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek 181a43484afda4c4fb4b23a53a2dc91d985d39dc2c4Ted KremenekS4 a_s4[100]; 18267d1287035767f4f6c8ca0c2bb755990012a44caTed KremenekS8 a_s8[100]; 18367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek 18467d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek// Check that malloc poisons memory. 18599ba9e3bd70671f3441fb974895f226a83ce0e66David Blaikie// A lot of tests below depend on this. 186dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted KremenekTEST(MemorySanitizerSanity, PoisonInMalloc) { 187dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek int *x = (int*)malloc(sizeof(int)); 188dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek EXPECT_POISONED(*x); 189dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek free(x); 190dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek} 191dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek 192dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted KremenekTEST(MemorySanitizer, NegativeTest1) { 193dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek S4 *x = GetPoisoned<S4>(); 194dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek if (g_one) 195eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks *x = 0; 196eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_NOT_POISONED(*x); 197eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks} 198eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks 199eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna ZaksTEST(MemorySanitizer, PositiveTest1) { 200dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek // Load to store. 20167d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(*GetPoisoned<S1>()); 202a43484afda4c4fb4b23a53a2dc91d985d39dc2c4Ted Kremenek EXPECT_POISONED(*GetPoisoned<S2>()); 203dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek EXPECT_POISONED(*GetPoisoned<S4>()); 204dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek EXPECT_POISONED(*GetPoisoned<S8>()); 205dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek 206dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek // S->S conversions. 207dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek EXPECT_POISONED(*GetPoisoned<S1>()); 208dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek EXPECT_POISONED(*GetPoisoned<S1>()); 209dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek EXPECT_POISONED(*GetPoisoned<S1>()); 210dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek 2119c378f705405d37f49795d5e915989de774fe11fTed Kremenek EXPECT_POISONED(*GetPoisoned<S2>()); 212fa87d812d7c78d7f0cd1c5636e21e07c23c85341Ted Kremenek EXPECT_POISONED(*GetPoisoned<S2>()); 213dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek EXPECT_POISONED(*GetPoisoned<S2>()); 214dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek 215dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek EXPECT_POISONED(*GetPoisoned<S4>()); 216dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek EXPECT_POISONED(*GetPoisoned<S4>()); 217dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek EXPECT_POISONED(*GetPoisoned<S4>()); 218dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek 219eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_POISONED(*GetPoisoned<S8>()); 220eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_POISONED(*GetPoisoned<S8>()); 221eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_POISONED(*GetPoisoned<S8>()); 222eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks 223eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks // ZExt 224eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_POISONED(*GetPoisoned<U1>()); 225eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_POISONED(*GetPoisoned<U1>()); 226dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek EXPECT_POISONED(*GetPoisoned<U1>()); 227dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek EXPECT_POISONED(*GetPoisoned<U2>()); 228dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek EXPECT_POISONED(*GetPoisoned<U2>()); 229eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_POISONED(*GetPoisoned<U4>()); 230eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks 231eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks // Unary ops. 232dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek EXPECT_POISONED(- *GetPoisoned<S4>()); 2339e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek 234fa87d812d7c78d7f0cd1c5636e21e07c23c85341Ted Kremenek EXPECT_UMR(a_s4[g_zero] = 100 / *GetPoisoned<S4>(0, 1)); 2359c378f705405d37f49795d5e915989de774fe11fTed Kremenek 236fa87d812d7c78d7f0cd1c5636e21e07c23c85341Ted Kremenek 23767d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek a_s4[g_zero] = 1 - *GetPoisoned<S4>(); 238eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks a_s4[g_zero] = 1 + *GetPoisoned<S4>(); 239eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks} 240eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks 24167d1287035767f4f6c8ca0c2bb755990012a44caTed KremenekTEST(MemorySanitizer, Phi1) { 24267d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek S4 c; 243eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks if (g_one) { 244eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks c = *GetPoisoned<S4>(); 245eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks } else { 246eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks break_optimization(0); 247eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks c = 0; 248eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks } 249eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_POISONED(c); 250eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks} 251eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks 252eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna ZaksTEST(MemorySanitizer, Phi2) { 253eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks S4 i = *GetPoisoned<S4>(); 254eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks S4 n = g_one; 255eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_UMR(for (; i < g_one; i++);); 256eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_POISONED(i); 257eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks} 258eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks 259eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna ZaksNOINLINE void Arg1ExpectUMR(S4 a1) { EXPECT_POISONED(a1); } 260eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna ZaksNOINLINE void Arg2ExpectUMR(S4 a1, S4 a2) { EXPECT_POISONED(a2); } 261eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna ZaksNOINLINE void Arg3ExpectUMR(S1 a1, S4 a2, S8 a3) { EXPECT_POISONED(a3); } 262eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks 263eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna ZaksTEST(MemorySanitizer, ArgTest) { 264eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks Arg1ExpectUMR(*GetPoisoned<S4>()); 265eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks Arg2ExpectUMR(0, *GetPoisoned<S4>()); 266eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks Arg3ExpectUMR(0, 1, *GetPoisoned<S8>()); 267eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks} 268eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks 269eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks 270eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna ZaksTEST(MemorySanitizer, CallAndRet) { 271eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks if (!__msan_has_dynamic_component()) return; 272eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks ReturnPoisoned<S1>(); 273eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks ReturnPoisoned<S2>(); 274eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks ReturnPoisoned<S4>(); 275eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks ReturnPoisoned<S8>(); 276eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks 277eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_POISONED(ReturnPoisoned<S1>()); 278eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_POISONED(ReturnPoisoned<S2>()); 279eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_POISONED(ReturnPoisoned<S4>()); 280eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_POISONED(ReturnPoisoned<S8>()); 281eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks} 282eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks 283eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks// malloc() in the following test may be optimized to produce a compile-time 284eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks// undef value. Check that we trap on the volatile assignment anyway. 285eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna ZaksTEST(MemorySanitizer, DISABLED_MallocNoIdent) { 286eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks S4 *x = (int*)malloc(sizeof(S4)); 287eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_POISONED(*x); 288eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks free(x); 289eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks} 290eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks 291eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna ZaksTEST(MemorySanitizer, Malloc) { 292eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks S4 *x = (int*)Ident(malloc(sizeof(S4))); 293eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_POISONED(*x); 294eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks free(x); 295eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks} 296eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks 297eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna ZaksTEST(MemorySanitizer, Realloc) { 298eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks S4 *x = (int*)Ident(realloc(0, sizeof(S4))); 29967d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(x[0]); 30099ba9e3bd70671f3441fb974895f226a83ce0e66David Blaikie x[0] = 1; 30167d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek x = (int*)Ident(realloc(x, 2 * sizeof(S4))); 30267d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(x[0]); // Ok, was inited before. 30367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(x[1]); 30467d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek x = (int*)Ident(realloc(x, 3 * sizeof(S4))); 30567d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(x[0]); // Ok, was inited before. 30667d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(x[2]); 30767d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(x[1]); 30867d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek x[2] = 1; // Init this here. Check that after realloc it is poisoned again. 30967d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek x = (int*)Ident(realloc(x, 2 * sizeof(S4))); 31067d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(x[0]); // Ok, was inited before. 3112b87ae45e129b941d0a4d221c9d4842385a119bdTed Kremenek EXPECT_POISONED(x[1]); 31299ba9e3bd70671f3441fb974895f226a83ce0e66David Blaikie x = (int*)Ident(realloc(x, 3 * sizeof(S4))); 3132b87ae45e129b941d0a4d221c9d4842385a119bdTed Kremenek EXPECT_POISONED(x[1]); 3142b87ae45e129b941d0a4d221c9d4842385a119bdTed Kremenek EXPECT_POISONED(x[2]); 3152b87ae45e129b941d0a4d221c9d4842385a119bdTed Kremenek free(x); 3162b87ae45e129b941d0a4d221c9d4842385a119bdTed Kremenek} 3172b87ae45e129b941d0a4d221c9d4842385a119bdTed Kremenek 3182b87ae45e129b941d0a4d221c9d4842385a119bdTed KremenekTEST(MemorySanitizer, Calloc) { 3192b87ae45e129b941d0a4d221c9d4842385a119bdTed Kremenek S4 *x = (int*)Ident(calloc(1, sizeof(S4))); 3202b87ae45e129b941d0a4d221c9d4842385a119bdTed Kremenek EXPECT_NOT_POISONED(*x); // Should not be poisoned. 3212b87ae45e129b941d0a4d221c9d4842385a119bdTed Kremenek // EXPECT_EQ(0, *x); 32267d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek free(x); 32367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek} 32467d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek 3259e24049bef26b6289cce9ac9b483c5cbb096e3aeTed KremenekTEST(MemorySanitizer, AndOr) { 32667d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek U4 *p = GetPoisoned<U4>(); 32767d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek // We poison two bytes in the midle of a 4-byte word to make the test 32867d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek // correct regardless of endianness. 32967d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek ((U1*)p)[1] = 0; 33067d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek ((U1*)p)[2] = 0xff; 33141168eac256fed59ec5406a75fce91c59cd5dd91Ted Kremenek EXPECT_NOT_POISONED(*p & 0x00ffff00); 33267d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(*p & 0x00ff0000); 33367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(*p & 0x0000ff00); 33467d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(*p & 0xff000000); 33567d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(*p & 0x000000ff); 33667d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(*p & 0x0000ffff); 33767d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(*p & 0xffff0000); 33867d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek 33967d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(*p | 0xff0000ff); 34067d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(*p | 0xff00ffff); 34167d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(*p | 0xffff00ff); 34267d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(*p | 0xff000000); 34367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(*p | 0x000000ff); 34467d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(*p | 0x0000ffff); 34599ba9e3bd70671f3441fb974895f226a83ce0e66David Blaikie EXPECT_POISONED(*p | 0xffff0000); 34667d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek 34767d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(*GetPoisoned<bool>() & *GetPoisoned<bool>()); 34867d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek} 34967d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek 35067d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenektemplate<class T> 35167d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenekstatic bool applyNot(T value, T shadow) { 35267d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek __msan_partial_poison(&value, &shadow, sizeof(T)); 35367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek return !value; 35467d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek} 35567d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek 35667d1287035767f4f6c8ca0c2bb755990012a44caTed KremenekTEST(MemorySanitizer, Not) { 35799ba9e3bd70671f3441fb974895f226a83ce0e66David Blaikie EXPECT_NOT_POISONED(applyNot<U4>(0x0, 0x0)); 35867d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(applyNot<U4>(0xFFFFFFFF, 0x0)); 35967d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(applyNot<U4>(0xFFFFFFFF, 0xFFFFFFFF)); 36067d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(applyNot<U4>(0xFF000000, 0x0FFFFFFF)); 36167d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(applyNot<U4>(0xFF000000, 0x00FFFFFF)); 36267d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(applyNot<U4>(0xFF000000, 0x0000FFFF)); 36367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(applyNot<U4>(0xFF000000, 0x00000000)); 3649e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek EXPECT_POISONED(applyNot<U4>(0xFF000000, 0xFF000000)); 3659e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek EXPECT_NOT_POISONED(applyNot<U4>(0xFF800000, 0xFF000000)); 3669e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek EXPECT_POISONED(applyNot<U4>(0x00008000, 0x00008000)); 3677caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu 368993f1c72913417be7c534ec7a634363cdfc84fa5Ted Kremenek EXPECT_NOT_POISONED(applyNot<U1>(0x0, 0x0)); 369993f1c72913417be7c534ec7a634363cdfc84fa5Ted Kremenek EXPECT_NOT_POISONED(applyNot<U1>(0xFF, 0xFE)); 370993f1c72913417be7c534ec7a634363cdfc84fa5Ted Kremenek EXPECT_NOT_POISONED(applyNot<U1>(0xFF, 0x0)); 37199ba9e3bd70671f3441fb974895f226a83ce0e66David Blaikie EXPECT_POISONED(applyNot<U1>(0xFF, 0xFF)); 37299ba9e3bd70671f3441fb974895f226a83ce0e66David Blaikie 3739e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek EXPECT_POISONED(applyNot<void*>((void*)0xFFFFFF, (void*)(-1))); 3741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump EXPECT_NOT_POISONED(applyNot<void*>((void*)0xFFFFFF, (void*)(-2))); 375993f1c72913417be7c534ec7a634363cdfc84fa5Ted Kremenek} 3769e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek 3779e24049bef26b6289cce9ac9b483c5cbb096e3aeTed KremenekTEST(MemorySanitizer, Shift) { 3789e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek U4 *up = GetPoisoned<U4>(); 3799e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek ((U1*)up)[0] = 0; 3801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ((U1*)up)[3] = 0xff; 38132f2656b90900ac04c4b50e87c16749d0ceb9ef2Jordy Rose EXPECT_NOT_POISONED(*up >> 30); 382c8413fd03f73084a5c93028f8b4db619fc388087Ted Kremenek EXPECT_NOT_POISONED(*up >> 24); 38332f2656b90900ac04c4b50e87c16749d0ceb9ef2Jordy Rose EXPECT_POISONED(*up >> 23); 38432f2656b90900ac04c4b50e87c16749d0ceb9ef2Jordy Rose EXPECT_POISONED(*up >> 10); 38532f2656b90900ac04c4b50e87c16749d0ceb9ef2Jordy Rose 386a43484afda4c4fb4b23a53a2dc91d985d39dc2c4Ted Kremenek EXPECT_NOT_POISONED(*up << 30); 3871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump EXPECT_NOT_POISONED(*up << 24); 3887e5d6ed47dcedce35043de59ee00464b681bc786Zhongxing Xu EXPECT_POISONED(*up << 23); 3891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump EXPECT_POISONED(*up << 10); 3909e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek 39167d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek S4 *sp = (S4*)up; 392993f1c72913417be7c534ec7a634363cdfc84fa5Ted Kremenek EXPECT_NOT_POISONED(*sp >> 30); 393993f1c72913417be7c534ec7a634363cdfc84fa5Ted Kremenek EXPECT_NOT_POISONED(*sp >> 24); 3941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump EXPECT_POISONED(*sp >> 23); 39519e1f0ba5cec738ce6cebe3fe0e1edc782206494Ted Kremenek EXPECT_POISONED(*sp >> 10); 39619e1f0ba5cec738ce6cebe3fe0e1edc782206494Ted Kremenek 3971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump sp = GetPoisoned<S4>(); 398ec13d9206645af07ef7c571405893b8d901de151Zhongxing Xu ((S1*)sp)[1] = 0; 39982bd99f4db2454cc6e1b7bfaac6db25cb3444ddcTed Kremenek ((S1*)sp)[2] = 0; 40082bd99f4db2454cc6e1b7bfaac6db25cb3444ddcTed Kremenek EXPECT_POISONED(*sp >> 31); 40182bd99f4db2454cc6e1b7bfaac6db25cb3444ddcTed Kremenek 40282bd99f4db2454cc6e1b7bfaac6db25cb3444ddcTed Kremenek EXPECT_POISONED(100 >> *GetPoisoned<S4>()); 40382bd99f4db2454cc6e1b7bfaac6db25cb3444ddcTed Kremenek EXPECT_POISONED(100U >> *GetPoisoned<S4>()); 40482bd99f4db2454cc6e1b7bfaac6db25cb3444ddcTed Kremenek} 40582bd99f4db2454cc6e1b7bfaac6db25cb3444ddcTed Kremenek 4069c378f705405d37f49795d5e915989de774fe11fTed KremenekNOINLINE static int GetPoisonedZero() { 40782bd99f4db2454cc6e1b7bfaac6db25cb3444ddcTed Kremenek int *zero = new int; 4089c378f705405d37f49795d5e915989de774fe11fTed Kremenek *zero = 0; 40982bd99f4db2454cc6e1b7bfaac6db25cb3444ddcTed Kremenek __msan_poison(zero, sizeof(*zero)); 4101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump int res = *zero; 41182bd99f4db2454cc6e1b7bfaac6db25cb3444ddcTed Kremenek delete zero; 4121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return res; 4139c378f705405d37f49795d5e915989de774fe11fTed Kremenek} 4149852b5bf94d4934de63da6356c651c61e81f58d9Zhongxing Xu 4159852b5bf94d4934de63da6356c651c61e81f58d9Zhongxing XuTEST(MemorySanitizer, LoadFromDirtyAddress) { 4169852b5bf94d4934de63da6356c651c61e81f58d9Zhongxing Xu int *a = new int; 417c8413fd03f73084a5c93028f8b4db619fc388087Ted Kremenek *a = 0; 41832f2656b90900ac04c4b50e87c16749d0ceb9ef2Jordy Rose EXPECT_UMR(break_optimization((void*)(U8)a[GetPoisonedZero()])); 41982bd99f4db2454cc6e1b7bfaac6db25cb3444ddcTed Kremenek delete a; 42082bd99f4db2454cc6e1b7bfaac6db25cb3444ddcTed Kremenek} 4219c378f705405d37f49795d5e915989de774fe11fTed Kremenek 4227ae7ad9951f032d0a33b64c964f7cdcb9cc6f59bTed KremenekTEST(MemorySanitizer, StoreToDirtyAddress) { 4231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump int *a = new int; 4249c378f705405d37f49795d5e915989de774fe11fTed Kremenek EXPECT_UMR(a[GetPoisonedZero()] = 0); 4251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump break_optimization(a); 42682bd99f4db2454cc6e1b7bfaac6db25cb3444ddcTed Kremenek delete a; 42782bd99f4db2454cc6e1b7bfaac6db25cb3444ddcTed Kremenek} 42882bd99f4db2454cc6e1b7bfaac6db25cb3444ddcTed Kremenek 4291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4301eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpNOINLINE void StackTestFunc() { 431993f1c72913417be7c534ec7a634363cdfc84fa5Ted Kremenek S4 p4; 432993f1c72913417be7c534ec7a634363cdfc84fa5Ted Kremenek S4 ok4 = 1; 43399ba9e3bd70671f3441fb974895f226a83ce0e66David Blaikie S2 p2; 43499ba9e3bd70671f3441fb974895f226a83ce0e66David Blaikie S2 ok2 = 1; 435993f1c72913417be7c534ec7a634363cdfc84fa5Ted Kremenek S1 p1; 436993f1c72913417be7c534ec7a634363cdfc84fa5Ted Kremenek S1 ok1 = 1; 4371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump break_optimization(&p4); 438993f1c72913417be7c534ec7a634363cdfc84fa5Ted Kremenek break_optimization(&ok4); 4399697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek break_optimization(&p2); 4409697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek break_optimization(&ok2); 4419697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek break_optimization(&p1); 4429697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek break_optimization(&ok1); 4439697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek 4449697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek EXPECT_POISONED(p4); 4459697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek EXPECT_POISONED(p2); 4469697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek EXPECT_POISONED(p1); 4479697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek EXPECT_NOT_POISONED(ok1); 4489697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek EXPECT_NOT_POISONED(ok2); 4499697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek EXPECT_NOT_POISONED(ok4); 4509697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek} 4519697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek 4529697934650354bed2e509d8e7e44f21a1fb00f76Ted KremenekTEST(MemorySanitizer, StackTest) { 4539697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek StackTestFunc(); 4549697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek} 45599ba9e3bd70671f3441fb974895f226a83ce0e66David Blaikie 45699ba9e3bd70671f3441fb974895f226a83ce0e66David BlaikieNOINLINE void StackStressFunc() { 4579697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek int foo[10000]; 4589697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek break_optimization(foo); 4599697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek} 4609697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek 461018220c343c103b7dfaa117a7a474c7a7fd6d068Zhongxing XuTEST(MemorySanitizer, DISABLED_StackStressTest) { 4621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (int i = 0; i < 1000000; i++) 463018220c343c103b7dfaa117a7a474c7a7fd6d068Zhongxing Xu StackStressFunc(); 4646eddeb153415049c7b62de4b45385a759a6906c6Ted Kremenek} 465a6b0b96e5376cd9cf182a3e240e0537feed43cdeTed Kremenek 466a6b0b96e5376cd9cf182a3e240e0537feed43cdeTed Kremenektemplate<class T> 467a6b0b96e5376cd9cf182a3e240e0537feed43cdeTed Kremenekvoid TestFloatingPoint() { 468a6b0b96e5376cd9cf182a3e240e0537feed43cdeTed Kremenek static volatile T v; 469a6b0b96e5376cd9cf182a3e240e0537feed43cdeTed Kremenek static T g[100]; 4706eddeb153415049c7b62de4b45385a759a6906c6Ted Kremenek break_optimization(&g); 4711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump T *x = GetPoisoned<T>(); 47249f4e1cbd839da27ff4814b4ea6d85a79f786cbdJohn McCall T *y = GetPoisoned<T>(1); 473018220c343c103b7dfaa117a7a474c7a7fd6d068Zhongxing Xu EXPECT_POISONED(*x); 4741ab55e9bb87d98bff1d42c7a0ee502c64755d9f5Douglas Gregor EXPECT_POISONED((long long)*x); 47514553abd17d303b0b310b3ab1523eb0d30d8121cTed Kremenek EXPECT_POISONED((int)*x); 4761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump g[0] = *x; 477993f1c72913417be7c534ec7a634363cdfc84fa5Ted Kremenek g[1] = *x + *y; 4789e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek g[2] = *x - *y; 4799697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek g[3] = *x * *y; 4809e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek} 4819e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek 4829e24049bef26b6289cce9ac9b483c5cbb096e3aeTed KremenekTEST(MemorySanitizer, FloatingPointTest) { 483ec13d9206645af07ef7c571405893b8d901de151Zhongxing Xu TestFloatingPoint<float>(); 484eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek TestFloatingPoint<double>(); 48599ba9e3bd70671f3441fb974895f226a83ce0e66David Blaikie} 48699ba9e3bd70671f3441fb974895f226a83ce0e66David Blaikie 487eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed KremenekTEST(MemorySanitizer, DynMem) { 488eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek S4 x = 0; 489ec13d9206645af07ef7c571405893b8d901de151Zhongxing Xu S4 *y = GetPoisoned<S4>(); 490eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek memcpy(y, &x, g_one * sizeof(S4)); 491eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek EXPECT_NOT_POISONED(*y); 492eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek} 493eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek 494eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenekstatic char *DynRetTestStr; 495eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek 496eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed KremenekTEST(MemorySanitizer, DynRet) { 497ec13d9206645af07ef7c571405893b8d901de151Zhongxing Xu if (!__msan_has_dynamic_component()) return; 498eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek ReturnPoisoned<S8>(); 499eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek EXPECT_NOT_POISONED(clearenv()); 500eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek} 501eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek 5029c378f705405d37f49795d5e915989de774fe11fTed Kremenek 503eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed KremenekTEST(MemorySanitizer, DynRet1) { 504eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek if (!__msan_has_dynamic_component()) return; 505018220c343c103b7dfaa117a7a474c7a7fd6d068Zhongxing Xu ReturnPoisoned<S8>(); 506018220c343c103b7dfaa117a7a474c7a7fd6d068Zhongxing Xu} 507ec13d9206645af07ef7c571405893b8d901de151Zhongxing Xu 508eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenekstruct LargeStruct { 509abd46e13cfd48f2c9bf26d9759edb4366aaa6d5bTed Kremenek S4 x[10]; 510abd46e13cfd48f2c9bf26d9759edb4366aaa6d5bTed Kremenek}; 51172e032004b0d2c2c298e8e4f7027f23a21c0cc7dTed Kremenek 512eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed KremenekNOINLINE 5139c378f705405d37f49795d5e915989de774fe11fTed KremenekLargeStruct LargeRetTest() { 514eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek LargeStruct res; 515ec13d9206645af07ef7c571405893b8d901de151Zhongxing Xu res.x[0] = *GetPoisoned<S4>(); 516eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek res.x[1] = *GetPoisoned<S4>(); 517abd46e13cfd48f2c9bf26d9759edb4366aaa6d5bTed Kremenek res.x[2] = *GetPoisoned<S4>(); 518abd46e13cfd48f2c9bf26d9759edb4366aaa6d5bTed Kremenek res.x[3] = *GetPoisoned<S4>(); 519eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek res.x[4] = *GetPoisoned<S4>(); 520ec13d9206645af07ef7c571405893b8d901de151Zhongxing Xu res.x[5] = *GetPoisoned<S4>(); 521eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek res.x[6] = *GetPoisoned<S4>(); 522eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek res.x[7] = *GetPoisoned<S4>(); 523eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek res.x[8] = *GetPoisoned<S4>(); 524eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek res.x[9] = *GetPoisoned<S4>(); 525eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek return res; 526eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek} 5270a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek 5280a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted KremenekTEST(MemorySanitizer, strcmp) { 5290a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek char s1[10]; 5300a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek char s2[10]; 5310a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek strncpy(s1, "foo", 10); 532eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek s2[0] = 'f'; 53367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek s2[1] = 'n'; 53467d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_GT(strcmp(s1, s2), 0); 535eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek s2[1] = 'o'; 5361d26f48dc2eea1c07431ca1519d7034a21b9bcffTed Kremenek int res; 537eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek EXPECT_UMR(res = strcmp(s1, s2)); 53867d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(res); 53967d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_EQ(strncmp(s1, s2, 1), 0); 5401d26f48dc2eea1c07431ca1519d7034a21b9bcffTed Kremenek} 54167d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek 54267d1287035767f4f6c8ca0c2bb755990012a44caTed KremenekTEST(MemorySanitizer, LargeRet) { 54367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek LargeStruct a = LargeRetTest(); 544018220c343c103b7dfaa117a7a474c7a7fd6d068Zhongxing Xu EXPECT_POISONED(a.x[0]); 545eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek EXPECT_POISONED(a.x[9]); 546eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek} 547eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek 548eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed KremenekTEST(MemorySanitizer, strerror) { 549eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek char *buf = strerror(EINVAL); 550eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek EXPECT_NOT_POISONED(strlen(buf)); 55167d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek buf = strerror(123456); 5521d26f48dc2eea1c07431ca1519d7034a21b9bcffTed Kremenek EXPECT_NOT_POISONED(strlen(buf)); 553eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek} 5549c378f705405d37f49795d5e915989de774fe11fTed Kremenek 555eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed KremenekTEST(MemorySanitizer, strerror_r) { 556eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek errno = 0; 557eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek char buf[1000]; 558eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek char *res = strerror_r(EINVAL, buf, sizeof(buf)); 5591d26f48dc2eea1c07431ca1519d7034a21b9bcffTed Kremenek ASSERT_EQ(0, errno); 56067d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek if (!res) res = buf; // POSIX version success. 561eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek EXPECT_NOT_POISONED(strlen(res)); 562eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek} 563eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek 564ec13d9206645af07ef7c571405893b8d901de151Zhongxing XuTEST(MemorySanitizer, fread) { 565ec13d9206645af07ef7c571405893b8d901de151Zhongxing Xu char *x = new char[32]; 5660a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek FILE *f = fopen("/proc/self/stat", "r"); 5670a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek assert(f); 5680a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek fread(x, 1, 32, f); 5690a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek EXPECT_NOT_POISONED(x[0]); 5700a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek EXPECT_NOT_POISONED(x[16]); 5710a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek EXPECT_NOT_POISONED(x[31]); 5720a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek fclose(f); 5730a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek delete x; 57467d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek} 5750a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek 57667d1287035767f4f6c8ca0c2bb755990012a44caTed KremenekTEST(MemorySanitizer, read) { 5774240096011a187807058f887eb81df750ffa17feTed Kremenek char *x = new char[32]; 57867d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek int fd = open("/proc/self/stat", O_RDONLY); 57967d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek assert(fd > 0); 5800a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek int sz = read(fd, x, 32); 5814240096011a187807058f887eb81df750ffa17feTed Kremenek assert(sz == 32); 5820a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek EXPECT_NOT_POISONED(x[0]); 58367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(x[16]); 5840a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek EXPECT_NOT_POISONED(x[31]); 5854240096011a187807058f887eb81df750ffa17feTed Kremenek close(fd); 586d02e83a548359df978f40cc1a52ffd78b7ef371bTed Kremenek delete x; 587d02e83a548359df978f40cc1a52ffd78b7ef371bTed Kremenek} 58881cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek 58981cef5889027d0f96b24afa7a0bb28d9023474edTed KremenekTEST(MemorySanitizer, pread) { 59081cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek char *x = new char[32]; 59181cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek int fd = open("/proc/self/stat", O_RDONLY); 59281cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek assert(fd > 0); 59381cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek int sz = pread(fd, x, 32, 0); 59481cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek assert(sz == 32); 59581cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek EXPECT_NOT_POISONED(x[0]); 59681cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek EXPECT_NOT_POISONED(x[16]); 59781cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek EXPECT_NOT_POISONED(x[31]); 59881cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek close(fd); 59981cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek delete x; 60081cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek} 60181cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek 60281cef5889027d0f96b24afa7a0bb28d9023474edTed KremenekTEST(MemorySanitizer, readv) { 60381cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek char buf[2011]; 60481cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek struct iovec iov[2]; 60581cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek iov[0].iov_base = buf + 1; 60681cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek iov[0].iov_len = 5; 6079c378f705405d37f49795d5e915989de774fe11fTed Kremenek iov[1].iov_base = buf + 10; 60881cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek iov[1].iov_len = 2000; 60981cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek int fd = open("/proc/self/stat", O_RDONLY); 61081cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek assert(fd > 0); 61181cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek int sz = readv(fd, iov, 2); 61281cef5889027d0f96b24afa7a0bb28d9023474edTed Kremenek ASSERT_LT(sz, 5 + 2000); 6134240096011a187807058f887eb81df750ffa17feTed Kremenek ASSERT_GT(sz, iov[0].iov_len); 6144240096011a187807058f887eb81df750ffa17feTed Kremenek EXPECT_POISONED(buf[0]); 6150a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek EXPECT_NOT_POISONED(buf[1]); 6169c378f705405d37f49795d5e915989de774fe11fTed Kremenek EXPECT_NOT_POISONED(buf[5]); 6170a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek EXPECT_POISONED(buf[6]); 6180a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek EXPECT_POISONED(buf[9]); 6190a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek EXPECT_NOT_POISONED(buf[10]); 62067d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(buf[10 + (sz - 1) - 5]); 62167d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(buf[11 + (sz - 1) - 5]); 6220a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek close(fd); 6230a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek} 6240a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek 6250a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted KremenekTEST(MemorySanitizer, preadv) { 6264240096011a187807058f887eb81df750ffa17feTed Kremenek char buf[2011]; 6274240096011a187807058f887eb81df750ffa17feTed Kremenek struct iovec iov[2]; 6280a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek iov[0].iov_base = buf + 1; 629ec13d9206645af07ef7c571405893b8d901de151Zhongxing Xu iov[0].iov_len = 5; 630026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu iov[1].iov_base = buf + 10; 631026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu iov[1].iov_len = 2000; 632026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu int fd = open("/proc/self/stat", O_RDONLY); 633026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu assert(fd > 0); 634026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu int sz = preadv(fd, iov, 2, 3); 635e8e86482da4c1872673bbb9c237649229d19793bTed Kremenek ASSERT_LT(sz, 5 + 2000); 636026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu ASSERT_GT(sz, iov[0].iov_len); 637026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu EXPECT_POISONED(buf[0]); 638026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu EXPECT_NOT_POISONED(buf[1]); 639026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu EXPECT_NOT_POISONED(buf[5]); 6401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump EXPECT_POISONED(buf[6]); 641e8e86482da4c1872673bbb9c237649229d19793bTed Kremenek EXPECT_POISONED(buf[9]); 6421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump EXPECT_NOT_POISONED(buf[10]); 643026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu EXPECT_NOT_POISONED(buf[10 + (sz - 1) - 5]); 644026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu EXPECT_POISONED(buf[11 + (sz - 1) - 5]); 645026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu close(fd); 646026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu} 6479852b5bf94d4934de63da6356c651c61e81f58d9Zhongxing Xu 6489852b5bf94d4934de63da6356c651c61e81f58d9Zhongxing Xu// FIXME: fails now. 649c8413fd03f73084a5c93028f8b4db619fc388087Ted KremenekTEST(MemorySanitizer, DISABLED_ioctl) { 65032f2656b90900ac04c4b50e87c16749d0ceb9ef2Jordy Rose struct winsize ws; 651026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu EXPECT_EQ(ioctl(2, TIOCGWINSZ, &ws), 0); 652026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu EXPECT_NOT_POISONED(ws.ws_col); 653250101353b711a409b075f1bc11070dddec7100bTed Kremenek} 654250101353b711a409b075f1bc11070dddec7100bTed Kremenek 655250101353b711a409b075f1bc11070dddec7100bTed KremenekTEST(MemorySanitizer, readlink) { 6561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump char *x = new char[1000]; 6579c378f705405d37f49795d5e915989de774fe11fTed Kremenek readlink("/proc/self/exe", x, 1000); 6581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump EXPECT_NOT_POISONED(x[0]); 659026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu delete [] x; 660026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu} 661026c66395b88a09437319139a43b090093f7e1ddZhongxing Xu 6621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 663026c66395b88a09437319139a43b090093f7e1ddZhongxing XuTEST(MemorySanitizer, stat) { 664e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu struct stat* st = new struct stat; 6659697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek int res = stat("/proc/self/stat", st); 666e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu assert(!res); 667e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu EXPECT_NOT_POISONED(st->st_dev); 668e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu EXPECT_NOT_POISONED(st->st_mode); 669e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu EXPECT_NOT_POISONED(st->st_size); 670250101353b711a409b075f1bc11070dddec7100bTed Kremenek} 6719697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek 672e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing XuTEST(MemorySanitizer, statfs) { 673e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu struct statfs* st = new struct statfs; 674e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu int res = statfs("/", st); 675e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu assert(!res); 676e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu EXPECT_NOT_POISONED(st->f_type); 677e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu EXPECT_NOT_POISONED(st->f_bfree); 6786613d08a19aa6ce9b6330487f3bfac841d4b8a4dZhongxing Xu EXPECT_NOT_POISONED(st->f_namelen); 6796613d08a19aa6ce9b6330487f3bfac841d4b8a4dZhongxing Xu} 6801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 681018220c343c103b7dfaa117a7a474c7a7fd6d068Zhongxing XuTEST(MemorySanitizer, pipe) { 682ff6978263439e21d795b0602fabcb38488ef8441Zhongxing Xu int* pipefd = new int[2]; 683ff6978263439e21d795b0602fabcb38488ef8441Zhongxing Xu int res = pipe(pipefd); 684e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu assert(!res); 685c8413fd03f73084a5c93028f8b4db619fc388087Ted Kremenek EXPECT_NOT_POISONED(pipefd[0]); 68632f2656b90900ac04c4b50e87c16749d0ceb9ef2Jordy Rose EXPECT_NOT_POISONED(pipefd[1]); 6870a51f1c6cec6032bcf64ce205bc4edfdc3cb3a2fZhongxing Xu close(pipefd[0]); 6880a51f1c6cec6032bcf64ce205bc4edfdc3cb3a2fZhongxing Xu close(pipefd[1]); 689e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu} 690e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu 691e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing XuTEST(MemorySanitizer, pipe2) { 692e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu int* pipefd = new int[2]; 6939c378f705405d37f49795d5e915989de774fe11fTed Kremenek int res = pipe2(pipefd, O_NONBLOCK); 694cc128b32429494fe04ed36d7ba30c011cb4e173aZhongxing Xu assert(!res); 695e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu EXPECT_NOT_POISONED(pipefd[0]); 696e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu EXPECT_NOT_POISONED(pipefd[1]); 697e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu close(pipefd[0]); 698e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu close(pipefd[1]); 6994c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek} 7004c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek 7014c62b557e269a27515dfca1f754ae936c8fdb824Ted KremenekTEST(MemorySanitizer, socketpair) { 7024c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek int sv[2]; 7034c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek int res = socketpair(AF_UNIX, SOCK_STREAM, 0, sv); 7044c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek assert(!res); 7054c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek EXPECT_NOT_POISONED(sv[0]); 7064c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek EXPECT_NOT_POISONED(sv[1]); 7074c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek close(sv[0]); 7084c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek close(sv[1]); 7094c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek} 7104c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek 7114c62b557e269a27515dfca1f754ae936c8fdb824Ted KremenekTEST(MemorySanitizer, poll) { 7124c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek int* pipefd = new int[2]; 7134c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek int res = pipe(pipefd); 7144c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek ASSERT_EQ(0, res); 7154c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek 7164c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek char data = 42; 7174c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek res = write(pipefd[1], &data, 1); 7184c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek ASSERT_EQ(1, res); 7194c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek 7204c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek pollfd fds[2]; 7214c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek fds[0].fd = pipefd[0]; 7224c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek fds[0].events = POLLIN; 7234c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek fds[1].fd = pipefd[1]; 7244c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek fds[1].events = POLLIN; 7254c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek res = poll(fds, 2, 500); 7264c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek ASSERT_EQ(1, res); 7274c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek EXPECT_NOT_POISONED(fds[0].revents); 7284c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek EXPECT_NOT_POISONED(fds[1].revents); 7294c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek 7304c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek close(pipefd[0]); 7314c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek close(pipefd[1]); 7324c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek} 733e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu 734329d6fde79254503b14724e1231a9d70fa6b387fTed KremenekTEST(MemorySanitizer, ppoll) { 735329d6fde79254503b14724e1231a9d70fa6b387fTed Kremenek int* pipefd = new int[2]; 736329d6fde79254503b14724e1231a9d70fa6b387fTed Kremenek int res = pipe(pipefd); 7379697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek ASSERT_EQ(0, res); 738329d6fde79254503b14724e1231a9d70fa6b387fTed Kremenek 739329d6fde79254503b14724e1231a9d70fa6b387fTed Kremenek char data = 42; 7409c378f705405d37f49795d5e915989de774fe11fTed Kremenek res = write(pipefd[1], &data, 1); 741329d6fde79254503b14724e1231a9d70fa6b387fTed Kremenek ASSERT_EQ(1, res); 7429c378f705405d37f49795d5e915989de774fe11fTed Kremenek 7439697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek pollfd fds[2]; 7441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump fds[0].fd = pipefd[0]; 745329d6fde79254503b14724e1231a9d70fa6b387fTed Kremenek fds[0].events = POLLIN; 7469c378f705405d37f49795d5e915989de774fe11fTed Kremenek fds[1].fd = pipefd[1]; 747329d6fde79254503b14724e1231a9d70fa6b387fTed Kremenek fds[1].events = POLLIN; 748329d6fde79254503b14724e1231a9d70fa6b387fTed Kremenek sigset_t ss; 749018220c343c103b7dfaa117a7a474c7a7fd6d068Zhongxing Xu sigemptyset(&ss); 750018220c343c103b7dfaa117a7a474c7a7fd6d068Zhongxing Xu res = ppoll(fds, 2, NULL, &ss); 75177cfac623178d0c16e16e2f171d20b0fea8fde30Zhongxing Xu ASSERT_EQ(1, res); 7520a51f1c6cec6032bcf64ce205bc4edfdc3cb3a2fZhongxing Xu EXPECT_NOT_POISONED(fds[0].revents); 7539a08fee80a34938b8c11c7166e009a89ced4c2b4Zhongxing Xu EXPECT_NOT_POISONED(fds[1].revents); 7549a08fee80a34938b8c11c7166e009a89ced4c2b4Zhongxing Xu 755329d6fde79254503b14724e1231a9d70fa6b387fTed Kremenek close(pipefd[0]); 7561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump close(pipefd[1]); 7579c378f705405d37f49795d5e915989de774fe11fTed Kremenek} 758329d6fde79254503b14724e1231a9d70fa6b387fTed Kremenek 7599c378f705405d37f49795d5e915989de774fe11fTed KremenekTEST(MemorySanitizer, poll_positive) { 7601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump int* pipefd = new int[2]; 761329d6fde79254503b14724e1231a9d70fa6b387fTed Kremenek int res = pipe(pipefd); 762329d6fde79254503b14724e1231a9d70fa6b387fTed Kremenek ASSERT_EQ(0, res); 763329d6fde79254503b14724e1231a9d70fa6b387fTed Kremenek 764329d6fde79254503b14724e1231a9d70fa6b387fTed Kremenek pollfd fds[2]; 765178927517fa09ddbb04dc8ef725b5716c18aae21Zhongxing Xu fds[0].fd = pipefd[0]; 7669697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek fds[0].events = POLLIN; 7679e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek // fds[1].fd uninitialized 7689c378f705405d37f49795d5e915989de774fe11fTed Kremenek fds[1].events = POLLIN; 7699e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek EXPECT_UMR(poll(fds, 2, 0)); 7709c378f705405d37f49795d5e915989de774fe11fTed Kremenek 7719697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek close(pipefd[0]); 7729e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek close(pipefd[1]); 7739c378f705405d37f49795d5e915989de774fe11fTed Kremenek} 7749e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek 7751eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpTEST(MemorySanitizer, bind_getsockname) { 776bfb6582ef46dfb33672d9621f879fc262339d704Zhongxing Xu int sock = socket(AF_UNIX, SOCK_STREAM, 0); 7779c378f705405d37f49795d5e915989de774fe11fTed Kremenek 7789e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek struct sockaddr_in sai; 7791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump memset(&sai, 0, sizeof(sai)); 780c8413fd03f73084a5c93028f8b4db619fc388087Ted Kremenek sai.sin_family = AF_UNIX; 78132f2656b90900ac04c4b50e87c16749d0ceb9ef2Jordy Rose int res = bind(sock, (struct sockaddr *)&sai, sizeof(sai)); 782e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu 783e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu assert(!res); 78467d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek char buf[200]; 785e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu socklen_t addrlen; 7869e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek EXPECT_UMR(getsockname(sock, (struct sockaddr *)&buf, &addrlen)); 7871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7889e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek addrlen = sizeof(buf); 7899e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek res = getsockname(sock, (struct sockaddr *)&buf, &addrlen); 790d17da2b99f323fa91b01e1dd119cc32e0ee8197dTed Kremenek EXPECT_NOT_POISONED(addrlen); 791d17da2b99f323fa91b01e1dd119cc32e0ee8197dTed Kremenek EXPECT_NOT_POISONED(buf[0]); 7929c378f705405d37f49795d5e915989de774fe11fTed Kremenek EXPECT_NOT_POISONED(buf[addrlen - 1]); 79367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(buf[addrlen]); 7949e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek close(sock); 7959c378f705405d37f49795d5e915989de774fe11fTed Kremenek} 796d17da2b99f323fa91b01e1dd119cc32e0ee8197dTed Kremenek 7979e24049bef26b6289cce9ac9b483c5cbb096e3aeTed KremenekTEST(MemorySanitizer, accept) { 7989e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek int listen_socket = socket(AF_INET, SOCK_STREAM, 0); 7991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ASSERT_LT(0, listen_socket); 800d17da2b99f323fa91b01e1dd119cc32e0ee8197dTed Kremenek 8011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump struct sockaddr_in sai; 8021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump sai.sin_family = AF_INET; 803d17da2b99f323fa91b01e1dd119cc32e0ee8197dTed Kremenek sai.sin_port = 0; 8041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump sai.sin_addr.s_addr = htonl(INADDR_LOOPBACK); 8055348f94abd0e9d3945da8d059b55b156967e8ff9Ted Kremenek int res = bind(listen_socket, (struct sockaddr *)&sai, sizeof(sai)); 8065348f94abd0e9d3945da8d059b55b156967e8ff9Ted Kremenek ASSERT_EQ(0, res); 807018220c343c103b7dfaa117a7a474c7a7fd6d068Zhongxing Xu 8086eddeb153415049c7b62de4b45385a759a6906c6Ted Kremenek res = listen(listen_socket, 1); 809018220c343c103b7dfaa117a7a474c7a7fd6d068Zhongxing Xu ASSERT_EQ(0, res); 8101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 8111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump socklen_t sz = sizeof(sai); 8129c378f705405d37f49795d5e915989de774fe11fTed Kremenek res = getsockname(listen_socket, (struct sockaddr *)&sai, &sz); 8131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ASSERT_EQ(0, res); 8149e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek ASSERT_EQ(sizeof(sai), sz); 8159e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek 8161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump int connect_socket = socket(AF_INET, SOCK_STREAM, 0); 8179e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek ASSERT_LT(0, connect_socket); 818de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek res = fcntl(connect_socket, F_SETFL, O_NONBLOCK); 819de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek ASSERT_EQ(0, res); 820de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek res = connect(connect_socket, (struct sockaddr *)&sai, sizeof(sai)); 821de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek ASSERT_EQ(-1, res); 8229697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek ASSERT_EQ(EINPROGRESS, errno); 823de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek 824de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek __msan_poison(&sai, sizeof(sai)); 825de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek int new_sock = accept(listen_socket, (struct sockaddr *)&sai, &sz); 8269697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek ASSERT_LT(0, new_sock); 827de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek ASSERT_EQ(sizeof(sai), sz); 828de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek EXPECT_NOT_POISONED(sai); 829de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek 830de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek __msan_poison(&sai, sizeof(sai)); 831de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek res = getpeername(new_sock, (struct sockaddr *)&sai, &sz); 832de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek ASSERT_EQ(0, res); 833de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek ASSERT_EQ(sizeof(sai), sz); 834de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek EXPECT_NOT_POISONED(sai); 835018220c343c103b7dfaa117a7a474c7a7fd6d068Zhongxing Xu 836de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek close(new_sock); 837de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek close(connect_socket); 8387caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu close(listen_socket); 8399c378f705405d37f49795d5e915989de774fe11fTed Kremenek} 840de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek 841de0d26310191215a6d1d189dc419f87af18ce6beTed KremenekTEST(MemorySanitizer, getaddrinfo) { 842de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek struct addrinfo *ai; 843de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek struct addrinfo hints; 844de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek memset(&hints, 0, sizeof(hints)); 845de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek hints.ai_family = AF_INET; 846de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek int res = getaddrinfo("localhost", NULL, &hints, &ai); 847de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek ASSERT_EQ(0, res); 8489e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek EXPECT_NOT_POISONED(*ai); 8499e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek ASSERT_EQ(sizeof(sockaddr_in), ai->ai_addrlen); 8509e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek EXPECT_NOT_POISONED(*(sockaddr_in*)ai->ai_addr); 8519e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek} 8529c378f705405d37f49795d5e915989de774fe11fTed Kremenek 8539e24049bef26b6289cce9ac9b483c5cbb096e3aeTed KremenekTEST(MemorySanitizer, getnameinfo) { 8549e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek struct sockaddr_in sai; 8554bd1eefd48c70ebef185e524d0484c00f16000cfTed Kremenek sai.sin_family = AF_INET; 8561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump sai.sin_port = 80; 8579c378f705405d37f49795d5e915989de774fe11fTed Kremenek sai.sin_addr.s_addr = htonl(INADDR_LOOPBACK); 8581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump char host[500]; 8599c378f705405d37f49795d5e915989de774fe11fTed Kremenek char serv[500]; 8601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump int res = getnameinfo((struct sockaddr *)&sai, sizeof(sai), host, 861018220c343c103b7dfaa117a7a474c7a7fd6d068Zhongxing Xu sizeof(host), serv, sizeof(serv), 0); 8626eddeb153415049c7b62de4b45385a759a6906c6Ted Kremenek ASSERT_EQ(0, res); 863018220c343c103b7dfaa117a7a474c7a7fd6d068Zhongxing Xu EXPECT_NOT_POISONED(host[0]); 8641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump EXPECT_POISONED(host[sizeof(host) - 1]); 8654bd1eefd48c70ebef185e524d0484c00f16000cfTed Kremenek 866c8413fd03f73084a5c93028f8b4db619fc388087Ted Kremenek ASSERT_NE(0, strlen(host)); 86732f2656b90900ac04c4b50e87c16749d0ceb9ef2Jordy Rose EXPECT_NOT_POISONED(serv[0]); 8689c378f705405d37f49795d5e915989de774fe11fTed Kremenek EXPECT_POISONED(serv[sizeof(serv) - 1]); 8696304b08daee27b25ae2e2bdb8bffd67dfad74b3cTed Kremenek ASSERT_NE(0, strlen(serv)); 8709e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek} 8719e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek 8721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump#define EXPECT_HOSTENT_NOT_POISONED(he) \ 8739e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek do { \ 8749e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek EXPECT_NOT_POISONED(*(he)); \ 8759e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek ASSERT_NE((void *) 0, (he)->h_name); \ 8769e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek ASSERT_NE((void *) 0, (he)->h_aliases); \ 8771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ASSERT_NE((void *) 0, (he)->h_addr_list); \ 8789e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek EXPECT_NOT_POISONED(strlen((he)->h_name)); \ 8791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump char **p = (he)->h_aliases; \ 8809e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek while (*p) { \ 8811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump EXPECT_NOT_POISONED(strlen(*p)); \ 882c35fb7d67d515659ad2325b4f6ec97c9fe64fb63Benjamin Kramer ++p; \ 8839e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek } \ 8849c378f705405d37f49795d5e915989de774fe11fTed Kremenek char **q = (he)->h_addr_list; \ 885c35fb7d67d515659ad2325b4f6ec97c9fe64fb63Benjamin Kramer while (*q) { \ 8861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump EXPECT_NOT_POISONED(*q[0]); \ 8879e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek ++q; \ 888c35fb7d67d515659ad2325b4f6ec97c9fe64fb63Benjamin Kramer } \ 889c35fb7d67d515659ad2325b4f6ec97c9fe64fb63Benjamin Kramer EXPECT_NOT_POISONED(*q); \ 8901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } while (0) 8919c378f705405d37f49795d5e915989de774fe11fTed Kremenek 8921eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpTEST(MemorySanitizer, gethostent) { 8939e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek struct hostent *he = gethostent(); 8949e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek ASSERT_NE((void *)NULL, he); 8959e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek EXPECT_HOSTENT_NOT_POISONED(he); 8969e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek} 8977caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu 898fc8f0e14ad142ed811e90fbd9a30e419e301c717Chris Lattner#ifndef MSAN_TEST_DISABLE_GETHOSTBYNAME 8997caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu 9007caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing XuTEST(MemorySanitizer, gethostbyname) { 9017caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu struct hostent *he = gethostbyname("localhost"); 9027caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu ASSERT_NE((void *)NULL, he); 9037caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu EXPECT_HOSTENT_NOT_POISONED(he); 9047caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu} 9057caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu 9067caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu#endif // MSAN_TEST_DISABLE_GETHOSTBYNAME 9077caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu 9089ff2b13aee0f89d23ef4820218f9b88bb5e5c1c1Ken DyckTEST(MemorySanitizer, gethostbyname2) { 9097caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu struct hostent *he = gethostbyname2("localhost", AF_INET); 9109ff2b13aee0f89d23ef4820218f9b88bb5e5c1c1Ken Dyck ASSERT_NE((void *)NULL, he); 9117caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu EXPECT_HOSTENT_NOT_POISONED(he); 9127caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu} 9137caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu 9147caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing XuTEST(MemorySanitizer, gethostbyaddr) { 9159ff2b13aee0f89d23ef4820218f9b88bb5e5c1c1Ken Dyck in_addr_t addr = inet_addr("127.0.0.1"); 9167caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu EXPECT_NOT_POISONED(addr); 9177caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu struct hostent *he = gethostbyaddr(&addr, sizeof(addr), AF_INET); 9189c378f705405d37f49795d5e915989de774fe11fTed Kremenek ASSERT_NE((void *)NULL, he); 9197caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu EXPECT_HOSTENT_NOT_POISONED(he); 9207caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu} 921511191ce8920160525611be2be754c32a0724c3eZhongxing Xu 9221437425a62dbf7bdb0a855d3ed3b05ed2019ec1eAnna ZaksTEST(MemorySanitizer, gethostent_r) { 9239697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek char buf[2000]; 924511191ce8920160525611be2be754c32a0724c3eZhongxing Xu struct hostent he; 925511191ce8920160525611be2be754c32a0724c3eZhongxing Xu struct hostent *result; 926f936f4568700d799e7d92eecef67b0e2b822ae7eTed Kremenek int err; 92702282acd7a42d06a3178e3102d34a585bd82dd9fTed Kremenek int res = gethostent_r(&he, buf, sizeof(buf), &result, &err); 928511191ce8920160525611be2be754c32a0724c3eZhongxing Xu ASSERT_EQ(0, res); 92902282acd7a42d06a3178e3102d34a585bd82dd9fTed Kremenek EXPECT_NOT_POISONED(result); 9309697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek ASSERT_NE((void *)NULL, result); 931f936f4568700d799e7d92eecef67b0e2b822ae7eTed Kremenek EXPECT_HOSTENT_NOT_POISONED(result); 9323d8173c1c68f451c7492f92023d829c626845925Chris Lattner EXPECT_NOT_POISONED(err); 9333d8173c1c68f451c7492f92023d829c626845925Chris Lattner} 93443b28d07019bc78447ecbbb721526de4ffd83f20Chris Lattner 9350395b5d4987fe5baa818015e9d294c128619e4ecZhongxing XuTEST(MemorySanitizer, gethostbyname_r) { 9361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump char buf[2000]; 937f936f4568700d799e7d92eecef67b0e2b822ae7eTed Kremenek struct hostent he; 938f936f4568700d799e7d92eecef67b0e2b822ae7eTed Kremenek struct hostent *result; 939511191ce8920160525611be2be754c32a0724c3eZhongxing Xu int err; 940511191ce8920160525611be2be754c32a0724c3eZhongxing Xu int res = gethostbyname_r("localhost", &he, buf, sizeof(buf), &result, &err); 941511191ce8920160525611be2be754c32a0724c3eZhongxing Xu ASSERT_EQ(0, res); 94202282acd7a42d06a3178e3102d34a585bd82dd9fTed Kremenek EXPECT_NOT_POISONED(result); 9436e78e1b22f3b16bb2ef76950b9b75f060bdba7bfZhongxing Xu ASSERT_NE((void *)NULL, result); 944018220c343c103b7dfaa117a7a474c7a7fd6d068Zhongxing Xu EXPECT_HOSTENT_NOT_POISONED(result); 945f936f4568700d799e7d92eecef67b0e2b822ae7eTed Kremenek EXPECT_NOT_POISONED(err); 946f936f4568700d799e7d92eecef67b0e2b822ae7eTed Kremenek} 9471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 948f936f4568700d799e7d92eecef67b0e2b822ae7eTed KremenekTEST(MemorySanitizer, gethostbyname2_r) { 949f936f4568700d799e7d92eecef67b0e2b822ae7eTed Kremenek char buf[2000]; 950abb042f33ea8e6107a7dc8efc51d2ace329f9f48Ted Kremenek struct hostent he; 9517caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu struct hostent *result; 9527caf9b369cba6edaf6eac25121cbc65ee938f14dZhongxing Xu int err; 9531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump int res = gethostbyname2_r("localhost", AF_INET, &he, buf, sizeof(buf), 9549c378f705405d37f49795d5e915989de774fe11fTed Kremenek &result, &err); 955b21ff77c8126ea628b66d2ffb931fdaa7884f5d2Zhongxing Xu ASSERT_EQ(0, res); 956511191ce8920160525611be2be754c32a0724c3eZhongxing Xu EXPECT_NOT_POISONED(result); 957511191ce8920160525611be2be754c32a0724c3eZhongxing Xu ASSERT_NE((void *)NULL, result); 958511191ce8920160525611be2be754c32a0724c3eZhongxing Xu EXPECT_HOSTENT_NOT_POISONED(result); 959511191ce8920160525611be2be754c32a0724c3eZhongxing Xu EXPECT_NOT_POISONED(err); 960511191ce8920160525611be2be754c32a0724c3eZhongxing Xu} 961511191ce8920160525611be2be754c32a0724c3eZhongxing Xu 96219e1f0ba5cec738ce6cebe3fe0e1edc782206494Ted KremenekTEST(MemorySanitizer, gethostbyaddr_r) { 963bc37b8dd9914e02580f531fa6e5e72be34d9675eZhongxing Xu char buf[2000]; 9649697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek struct hostent he; 965bb141217871e93767aa3f2de1b9946fa6d37066aZhongxing Xu struct hostent *result; 966bb141217871e93767aa3f2de1b9946fa6d37066aZhongxing Xu int err; 967bc37b8dd9914e02580f531fa6e5e72be34d9675eZhongxing Xu in_addr_t addr = inet_addr("127.0.0.1"); 968bb141217871e93767aa3f2de1b9946fa6d37066aZhongxing Xu EXPECT_NOT_POISONED(addr); 96902fe28c8a6da29d4ad88d0900c133dcf22d24a75Zhongxing Xu int res = gethostbyaddr_r(&addr, sizeof(addr), AF_INET, &he, buf, sizeof(buf), 9709697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek &result, &err); 971bb141217871e93767aa3f2de1b9946fa6d37066aZhongxing Xu ASSERT_EQ(0, res); 972bb141217871e93767aa3f2de1b9946fa6d37066aZhongxing Xu EXPECT_NOT_POISONED(result); 973bc37b8dd9914e02580f531fa6e5e72be34d9675eZhongxing Xu ASSERT_NE((void *)NULL, result); 974bb141217871e93767aa3f2de1b9946fa6d37066aZhongxing Xu EXPECT_HOSTENT_NOT_POISONED(result); 975bb141217871e93767aa3f2de1b9946fa6d37066aZhongxing Xu EXPECT_NOT_POISONED(err); 976782f63ecd124f9384f988dc7e0cf4ae1540c15f6Jeffrey Yasskin} 977782f63ecd124f9384f988dc7e0cf4ae1540c15f6Jeffrey Yasskin 978018220c343c103b7dfaa117a7a474c7a7fd6d068Zhongxing XuTEST(MemorySanitizer, getsockopt) { 979bc37b8dd9914e02580f531fa6e5e72be34d9675eZhongxing Xu int sock = socket(AF_UNIX, SOCK_STREAM, 0); 980bb141217871e93767aa3f2de1b9946fa6d37066aZhongxing Xu struct linger l[2]; 981bb141217871e93767aa3f2de1b9946fa6d37066aZhongxing Xu socklen_t sz = sizeof(l[0]); 9829c378f705405d37f49795d5e915989de774fe11fTed Kremenek int res = getsockopt(sock, SOL_SOCKET, SO_LINGER, &l[0], &sz); 983e1aeb13251a4858724d2b7ad1925d25076f23d08Zhongxing Xu ASSERT_EQ(0, res); 984bb141217871e93767aa3f2de1b9946fa6d37066aZhongxing Xu ASSERT_EQ(sizeof(l[0]), sz); 985bb141217871e93767aa3f2de1b9946fa6d37066aZhongxing Xu EXPECT_NOT_POISONED(l[0]); 986bb141217871e93767aa3f2de1b9946fa6d37066aZhongxing Xu EXPECT_POISONED(*(char *)(l + 1)); 98702fe28c8a6da29d4ad88d0900c133dcf22d24a75Zhongxing Xu} 988bb141217871e93767aa3f2de1b9946fa6d37066aZhongxing Xu 989bb141217871e93767aa3f2de1b9946fa6d37066aZhongxing XuTEST(MemorySanitizer, getcwd) { 990bb141217871e93767aa3f2de1b9946fa6d37066aZhongxing Xu char path[PATH_MAX + 1]; 9914fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu char* res = getcwd(path, sizeof(path)); 9924fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu assert(res); 9939697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek EXPECT_NOT_POISONED(path[0]); 9944fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu} 9954fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu 9964fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing XuTEST(MemorySanitizer, getcwd_gnu) { 9974fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu char* res = getcwd(NULL, 0); 9984fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu assert(res); 9999697934650354bed2e509d8e7e44f21a1fb00f76Ted Kremenek EXPECT_NOT_POISONED(res[0]); 10004fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu free(res); 10014fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu} 10024fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu 10034fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing XuTEST(MemorySanitizer, get_current_dir_name) { 10044fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu char* res = get_current_dir_name(); 1005d074441e027471a914cbb909a7aad1d43224950fZhongxing Xu assert(res); 1006d074441e027471a914cbb909a7aad1d43224950fZhongxing Xu EXPECT_NOT_POISONED(res[0]); 10074fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu free(res); 10084fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu} 10099c378f705405d37f49795d5e915989de774fe11fTed Kremenek 10104fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing XuTEST(MemorySanitizer, confstr) { 10114fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu char buf[3]; 10124fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu size_t res = confstr(_CS_PATH, buf, sizeof(buf)); 10134fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu ASSERT_GT(res, sizeof(buf)); 10144fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu EXPECT_NOT_POISONED(buf[0]); 10154fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu EXPECT_NOT_POISONED(buf[sizeof(buf) - 1]); 10164fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu 10174fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu char buf2[1000]; 1018ed65d3d97132fbcdd124aef4d2478e348dfbd36bTed Kremenek res = confstr(_CS_PATH, buf2, sizeof(buf2)); 1019ed65d3d97132fbcdd124aef4d2478e348dfbd36bTed Kremenek ASSERT_LT(res, sizeof(buf2)); 1020f7a0cf426eddae76e1a71dd2295631a2cf0560afTed Kremenek EXPECT_NOT_POISONED(buf2[0]); 1021f7a0cf426eddae76e1a71dd2295631a2cf0560afTed Kremenek EXPECT_NOT_POISONED(buf2[res - 1]); 10221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump EXPECT_POISONED(buf2[res]); 1023f7a0cf426eddae76e1a71dd2295631a2cf0560afTed Kremenek ASSERT_EQ(res, strlen(buf2) + 1); 1024ed65d3d97132fbcdd124aef4d2478e348dfbd36bTed Kremenek} 1025511191ce8920160525611be2be754c32a0724c3eZhongxing Xu 10269e24049bef26b6289cce9ac9b483c5cbb096e3aeTed KremenekTEST(MemorySanitizer, readdir) { 10279e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek DIR *dir = opendir("."); 10289e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek struct dirent *d = readdir(dir); 10299e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek assert(d); 10309e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek EXPECT_NOT_POISONED(d->d_name[0]); 1031a43484afda4c4fb4b23a53a2dc91d985d39dc2c4Ted Kremenek closedir(dir); 10329e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek} 10339e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek 10341eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpTEST(MemorySanitizer, readdir_r) { 1035eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks DIR *dir = opendir("."); 1036eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks struct dirent d; 1037eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks struct dirent *pd; 1038eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks int res = readdir_r(dir, &d, &pd); 10392b87ae45e129b941d0a4d221c9d4842385a119bdTed Kremenek assert(!res); 1040c30470dd245e2c3b367d3d806e75bf6cc20fc18cZhongxing Xu EXPECT_NOT_POISONED(pd); 1041c30470dd245e2c3b367d3d806e75bf6cc20fc18cZhongxing Xu EXPECT_NOT_POISONED(d.d_name[0]); 1042c30470dd245e2c3b367d3d806e75bf6cc20fc18cZhongxing Xu closedir(dir); 1043c30470dd245e2c3b367d3d806e75bf6cc20fc18cZhongxing Xu} 1044dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek 1045dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted KremenekTEST(MemorySanitizer, realpath) { 10462b87ae45e129b941d0a4d221c9d4842385a119bdTed Kremenek const char* relpath = "."; 104767d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek char path[PATH_MAX + 1]; 10482b87ae45e129b941d0a4d221c9d4842385a119bdTed Kremenek char* res = realpath(relpath, path); 1049d05552a21377f493c882298c59e8829040b01d34Ted Kremenek assert(res); 1050dc0a25d9bff956cdbe54ea0bfc8fbbe3ceb4eb92Zhongxing Xu EXPECT_NOT_POISONED(path[0]); 10519e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek} 1052a43484afda4c4fb4b23a53a2dc91d985d39dc2c4Ted Kremenek 1053eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna ZaksTEST(MemorySanitizer, realpath_null) { 1054eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks const char* relpath = "."; 10551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump char* res = realpath(relpath, NULL); 10564240096011a187807058f887eb81df750ffa17feTed Kremenek printf("%d, %s\n", errno, strerror(errno)); 10571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(res); 1058a43484afda4c4fb4b23a53a2dc91d985d39dc2c4Ted Kremenek EXPECT_NOT_POISONED(res[0]); 10594240096011a187807058f887eb81df750ffa17feTed Kremenek free(res); 10604240096011a187807058f887eb81df750ffa17feTed Kremenek} 10611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 106267d1287035767f4f6c8ca0c2bb755990012a44caTed KremenekTEST(MemorySanitizer, canonicalize_file_name) { 106367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek const char* relpath = "."; 106467d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek char* res = canonicalize_file_name(relpath); 106567d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek assert(res); 1066d05552a21377f493c882298c59e8829040b01d34Ted Kremenek EXPECT_NOT_POISONED(res[0]); 1067d05552a21377f493c882298c59e8829040b01d34Ted Kremenek free(res); 106867d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek} 106967d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek 107067d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenekextern char **environ; 10711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10729e24049bef26b6289cce9ac9b483c5cbb096e3aeTed KremenekTEST(MemorySanitizer, setenv) { 1073dcee3ce97fc76f20ce8f5a7451071e3dec537073Ted Kremenek setenv("AAA", "BBB", 1); 1074eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks for (char **envp = environ; *envp; ++envp) { 1075eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_NOT_POISONED(*envp); 1076eb31a76d1cdaaf8874c549dc6bd964ff270d3822Anna Zaks EXPECT_NOT_POISONED(*envp[0]); 10771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 10789e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek} 10799e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek 108067d1287035767f4f6c8ca0c2bb755990012a44caTed KremenekTEST(MemorySanitizer, putenv) { 1081178927517fa09ddbb04dc8ef725b5716c18aae21Zhongxing Xu char s[] = "AAA=BBB"; 1082178927517fa09ddbb04dc8ef725b5716c18aae21Zhongxing Xu putenv(s); 1083178927517fa09ddbb04dc8ef725b5716c18aae21Zhongxing Xu for (char **envp = environ; *envp; ++envp) { 1084b48ad64a0e9e8d6488adebe597b6af32c1eb84f4Ted Kremenek EXPECT_NOT_POISONED(*envp); 1085c540b261ac553b91840146eaa3fee3f11b1013a7Zhongxing Xu EXPECT_NOT_POISONED(*envp[0]); 1086b48ad64a0e9e8d6488adebe597b6af32c1eb84f4Ted Kremenek } 1087ec13d9206645af07ef7c571405893b8d901de151Zhongxing Xu} 10887090ae1a984eb446a5fb4da7b1f2573830653799Ted Kremenek 10899c378f705405d37f49795d5e915989de774fe11fTed KremenekTEST(MemorySanitizer, memcpy) { 109067d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek char* x = new char[2]; 10911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump char* y = new char[2]; 1092329d6fde79254503b14724e1231a9d70fa6b387fTed Kremenek x[0] = 1; 1093329d6fde79254503b14724e1231a9d70fa6b387fTed Kremenek x[1] = *GetPoisoned<char>(); 1094b48ad64a0e9e8d6488adebe597b6af32c1eb84f4Ted Kremenek memcpy(y, x, 2); 10959c378f705405d37f49795d5e915989de774fe11fTed Kremenek EXPECT_NOT_POISONED(y[0]); 109667d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(y[1]); 1097de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek} 1098fc8f0e14ad142ed811e90fbd9a30e419e301c717Chris Lattner 1099de0d26310191215a6d1d189dc419f87af18ce6beTed KremenekTEST(MemorySanitizer, memmove) { 1100de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek char* x = new char[2]; 1101de0d26310191215a6d1d189dc419f87af18ce6beTed Kremenek char* y = new char[2]; 11021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump x[0] = 1; 1103993f1c72913417be7c534ec7a634363cdfc84fa5Ted Kremenek x[1] = *GetPoisoned<char>(); 1104b48ad64a0e9e8d6488adebe597b6af32c1eb84f4Ted Kremenek memmove(y, x, 2); 1105e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing Xu EXPECT_NOT_POISONED(y[0]); 11064c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek EXPECT_POISONED(y[1]); 11074c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek} 11084c62b557e269a27515dfca1f754ae936c8fdb824Ted Kremenek 1109e9f4e5420895a75dd788e9891921e7781c1823b9Zhongxing XuTEST(MemorySanitizer, bcopy) { 11109e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek char* x = new char[2]; 1111d17da2b99f323fa91b01e1dd119cc32e0ee8197dTed Kremenek char* y = new char[2]; 1112b48ad64a0e9e8d6488adebe597b6af32c1eb84f4Ted Kremenek x[0] = 1; 11131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump x[1] = *GetPoisoned<char>(); 111467d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek bcopy(x, y, 2); 111567d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(y[0]); 111667d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(y[1]); 111767d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek} 1118f936f4568700d799e7d92eecef67b0e2b822ae7eTed Kremenek 1119f936f4568700d799e7d92eecef67b0e2b822ae7eTed KremenekTEST(MemorySanitizer, strdup) { 112002282acd7a42d06a3178e3102d34a585bd82dd9fTed Kremenek char buf[4] = "abc"; 1121856c6bcaea56e05255e9f3997ddd56b5c18a14f0Zhongxing Xu __msan_poison(buf + 2, sizeof(*buf)); 1122856c6bcaea56e05255e9f3997ddd56b5c18a14f0Zhongxing Xu char *x = strdup(buf); 11231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump EXPECT_NOT_POISONED(x[0]); 1124b48ad64a0e9e8d6488adebe597b6af32c1eb84f4Ted Kremenek EXPECT_NOT_POISONED(x[1]); 1125856c6bcaea56e05255e9f3997ddd56b5c18a14f0Zhongxing Xu EXPECT_POISONED(x[2]); 1126a5e81f1240bcc5b9b0721fc6275075ad7cadaf5eTed Kremenek EXPECT_NOT_POISONED(x[3]); 1127a5e81f1240bcc5b9b0721fc6275075ad7cadaf5eTed Kremenek free(x); 1128a5e81f1240bcc5b9b0721fc6275075ad7cadaf5eTed Kremenek} 1129511191ce8920160525611be2be754c32a0724c3eZhongxing Xu 11309e24049bef26b6289cce9ac9b483c5cbb096e3aeTed KremenekTEST(MemorySanitizer, strndup) { 11319e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek char buf[4] = "abc"; 11329e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek __msan_poison(buf + 2, sizeof(*buf)); 11339e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek char *x = strndup(buf, 3); 11349c378f705405d37f49795d5e915989de774fe11fTed Kremenek EXPECT_NOT_POISONED(x[0]); 1135b48ad64a0e9e8d6488adebe597b6af32c1eb84f4Ted Kremenek EXPECT_NOT_POISONED(x[1]); 11361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump EXPECT_POISONED(x[2]); 1137b48ad64a0e9e8d6488adebe597b6af32c1eb84f4Ted Kremenek EXPECT_NOT_POISONED(x[3]); 1138b48ad64a0e9e8d6488adebe597b6af32c1eb84f4Ted Kremenek free(x); 1139a5e81f1240bcc5b9b0721fc6275075ad7cadaf5eTed Kremenek} 1140a5e81f1240bcc5b9b0721fc6275075ad7cadaf5eTed Kremenek 11411eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpTEST(MemorySanitizer, strndup_short) { 11429e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek char buf[4] = "abc"; 11439e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek __msan_poison(buf + 1, sizeof(*buf)); 11449e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek __msan_poison(buf + 2, sizeof(*buf)); 11459e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek char *x = strndup(buf, 2); 11469c378f705405d37f49795d5e915989de774fe11fTed Kremenek EXPECT_NOT_POISONED(x[0]); 1147b48ad64a0e9e8d6488adebe597b6af32c1eb84f4Ted Kremenek EXPECT_POISONED(x[1]); 11481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump EXPECT_NOT_POISONED(x[2]); 114902fe28c8a6da29d4ad88d0900c133dcf22d24a75Zhongxing Xu free(x); 115002fe28c8a6da29d4ad88d0900c133dcf22d24a75Zhongxing Xu} 1151bb141217871e93767aa3f2de1b9946fa6d37066aZhongxing Xu 11524fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xu 11534fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xutemplate<class T, int size> 11544fd56816e0925c04f2c92e75399f5c9018d5d6fbZhongxing Xuvoid TestOverlapMemmove() { 1155d074441e027471a914cbb909a7aad1d43224950fZhongxing Xu T *x = new T[size]; 1156d074441e027471a914cbb909a7aad1d43224950fZhongxing Xu assert(size >= 3); 1157d074441e027471a914cbb909a7aad1d43224950fZhongxing Xu x[2] = 0; 1158d074441e027471a914cbb909a7aad1d43224950fZhongxing Xu memmove(x, x + 1, (size - 1) * sizeof(T)); 1159d074441e027471a914cbb909a7aad1d43224950fZhongxing Xu EXPECT_NOT_POISONED(x[1]); 1160d074441e027471a914cbb909a7aad1d43224950fZhongxing Xu if (!__msan_has_dynamic_component()) { 1161d074441e027471a914cbb909a7aad1d43224950fZhongxing Xu // FIXME: under DR we will lose this information 1162d074441e027471a914cbb909a7aad1d43224950fZhongxing Xu // because accesses in memmove will unpoisin the shadow. 1163b48ad64a0e9e8d6488adebe597b6af32c1eb84f4Ted Kremenek // We need to use our own memove implementation instead of libc's. 1164b48ad64a0e9e8d6488adebe597b6af32c1eb84f4Ted Kremenek EXPECT_POISONED(x[0]); 116567d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(x[2]); 11661d26f48dc2eea1c07431ca1519d7034a21b9bcffTed Kremenek } 116767d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek delete [] x; 116867d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek} 116967d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek 117067d1287035767f4f6c8ca0c2bb755990012a44caTed KremenekTEST(MemorySanitizer, overlap_memmove) { 117167d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek TestOverlapMemmove<U1, 10>(); 1172b48ad64a0e9e8d6488adebe597b6af32c1eb84f4Ted Kremenek TestOverlapMemmove<U1, 1000>(); 117367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek TestOverlapMemmove<U8, 4>(); 11741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TestOverlapMemmove<U8, 1000>(); 1175bcd7f9f8cb2f1b78e8ad991677a4364044e1deb7Ted Kremenek} 1176250101353b711a409b075f1bc11070dddec7100bTed Kremenek 1177250101353b711a409b075f1bc11070dddec7100bTed KremenekTEST(MemorySanitizer, strcpy) { // NOLINT 11781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump char* x = new char[3]; 11796304b08daee27b25ae2e2bdb8bffd67dfad74b3cTed Kremenek char* y = new char[3]; 1180eeea45611d45238c34474c183cee96d47ae79e24Ted Kremenek x[0] = 'a'; 11811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump x[1] = *GetPoisoned<char>(1, 1); 11827ae7ad9951f032d0a33b64c964f7cdcb9cc6f59bTed Kremenek x[2] = 0; 11837ae7ad9951f032d0a33b64c964f7cdcb9cc6f59bTed Kremenek strcpy(y, x); // NOLINT 1184dc0a25d9bff956cdbe54ea0bfc8fbbe3ceb4eb92Zhongxing Xu EXPECT_NOT_POISONED(y[0]); 11850a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek EXPECT_POISONED(y[1]); 11860a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek EXPECT_NOT_POISONED(y[2]); 11870a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek} 11880a8112a78d00b5140c5b7f16c3b34c2c0c13c1a0Ted Kremenek 118967d1287035767f4f6c8ca0c2bb755990012a44caTed KremenekTEST(MemorySanitizer, strncpy) { // NOLINT 119067d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek char* x = new char[3]; 119167d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek char* y = new char[3]; 119267d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek x[0] = 'a'; 119367d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek x[1] = *GetPoisoned<char>(1, 1); 119467d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek x[2] = 0; 119567d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek strncpy(y, x, 2); // NOLINT 119667d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_NOT_POISONED(y[0]); 119767d1287035767f4f6c8ca0c2bb755990012a44caTed Kremenek EXPECT_POISONED(y[1]); 1198ed65d3d97132fbcdd124aef4d2478e348dfbd36bTed Kremenek EXPECT_POISONED(y[2]); 11991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump} 1200250101353b711a409b075f1bc11070dddec7100bTed Kremenek 1201a43484afda4c4fb4b23a53a2dc91d985d39dc2c4Ted KremenekTEST(MemorySanitizer, stpcpy) { // NOLINT 1202250101353b711a409b075f1bc11070dddec7100bTed Kremenek char* x = new char[3]; 1203250101353b711a409b075f1bc11070dddec7100bTed Kremenek char* y = new char[3]; 12049c378f705405d37f49795d5e915989de774fe11fTed Kremenek x[0] = 'a'; 1205a43484afda4c4fb4b23a53a2dc91d985d39dc2c4Ted Kremenek x[1] = *GetPoisoned<char>(1, 1); 1206a43484afda4c4fb4b23a53a2dc91d985d39dc2c4Ted Kremenek x[2] = 0; 1207eb1c7a04509f5d25c09005a6d46bd8bbb3ca88cbTed Kremenek char *res = stpcpy(y, x); // NOLINT 12085a4f98ff943e6a501b0fe47ade007c9bbf96cb88Argyrios Kyrtzidis ASSERT_EQ(res, y + 2); 12095a4f98ff943e6a501b0fe47ade007c9bbf96cb88Argyrios Kyrtzidis EXPECT_NOT_POISONED(y[0]); 1210be91224894e1501133e224934285ba6440bf5b59Ted Kremenek EXPECT_POISONED(y[1]); 12119e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek EXPECT_NOT_POISONED(y[2]); 1212250101353b711a409b075f1bc11070dddec7100bTed Kremenek} 1213250101353b711a409b075f1bc11070dddec7100bTed Kremenek 1214250101353b711a409b075f1bc11070dddec7100bTed KremenekTEST(MemorySanitizer, strtol) { 1215250101353b711a409b075f1bc11070dddec7100bTed Kremenek char *e; 1216be91224894e1501133e224934285ba6440bf5b59Ted Kremenek assert(1 == strtol("1", &e, 10)); 12179c378f705405d37f49795d5e915989de774fe11fTed Kremenek EXPECT_NOT_POISONED((S8) e); 12189ef6537a894c33003359b1f9b9676e9178e028b7Ted Kremenek} 12198800ad4eaa1621f6d23c8264971063b9f8da6a2eTed Kremenek 12208800ad4eaa1621f6d23c8264971063b9f8da6a2eTed KremenekTEST(MemorySanitizer, strtoll) { 1221be91224894e1501133e224934285ba6440bf5b59Ted Kremenek char *e; 1222be91224894e1501133e224934285ba6440bf5b59Ted Kremenek assert(1 == strtoll("1", &e, 10)); 12239e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek EXPECT_NOT_POISONED((S8) e); 12249e24049bef26b6289cce9ac9b483c5cbb096e3aeTed Kremenek} 1225 1226TEST(MemorySanitizer, strtoul) { 1227 char *e; 1228 assert(1 == strtoul("1", &e, 10)); 1229 EXPECT_NOT_POISONED((S8) e); 1230} 1231 1232TEST(MemorySanitizer, strtoull) { 1233 char *e; 1234 assert(1 == strtoull("1", &e, 10)); 1235 EXPECT_NOT_POISONED((S8) e); 1236} 1237 1238TEST(MemorySanitizer, strtoimax) { 1239 char *e; 1240 assert(1 == strtoimax("1", &e, 10)); 1241 EXPECT_NOT_POISONED((S8) e); 1242} 1243 1244TEST(MemorySanitizer, strtoumax) { 1245 char *e; 1246 assert(1 == strtoumax("1", &e, 10)); 1247 EXPECT_NOT_POISONED((S8) e); 1248} 1249 1250TEST(MemorySanitizer, strtod) { 1251 char *e; 1252 assert(0 != strtod("1.5", &e)); 1253 EXPECT_NOT_POISONED((S8) e); 1254} 1255 1256TEST(MemorySanitizer, strtof) { 1257 char *e; 1258 assert(0 != strtof("1.5", &e)); 1259 EXPECT_NOT_POISONED((S8) e); 1260} 1261 1262TEST(MemorySanitizer, strtold) { 1263 char *e; 1264 assert(0 != strtold("1.5", &e)); 1265 EXPECT_NOT_POISONED((S8) e); 1266} 1267 1268TEST(MemorySanitizer, modf) { 1269 double x, y; 1270 x = modf(2.1, &y); 1271 EXPECT_NOT_POISONED(y); 1272} 1273 1274TEST(MemorySanitizer, modff) { 1275 float x, y; 1276 x = modff(2.1, &y); 1277 EXPECT_NOT_POISONED(y); 1278} 1279 1280TEST(MemorySanitizer, modfl) { 1281 long double x, y; 1282 x = modfl(2.1, &y); 1283 EXPECT_NOT_POISONED(y); 1284} 1285 1286TEST(MemorySanitizer, sprintf) { // NOLINT 1287 char buff[10]; 1288 break_optimization(buff); 1289 EXPECT_POISONED(buff[0]); 1290 int res = sprintf(buff, "%d", 1234567); // NOLINT 1291 assert(res == 7); 1292 assert(buff[0] == '1'); 1293 assert(buff[1] == '2'); 1294 assert(buff[2] == '3'); 1295 assert(buff[6] == '7'); 1296 assert(buff[7] == 0); 1297 EXPECT_POISONED(buff[8]); 1298} 1299 1300TEST(MemorySanitizer, snprintf) { 1301 char buff[10]; 1302 break_optimization(buff); 1303 EXPECT_POISONED(buff[0]); 1304 int res = snprintf(buff, sizeof(buff), "%d", 1234567); 1305 assert(res == 7); 1306 assert(buff[0] == '1'); 1307 assert(buff[1] == '2'); 1308 assert(buff[2] == '3'); 1309 assert(buff[6] == '7'); 1310 assert(buff[7] == 0); 1311 EXPECT_POISONED(buff[8]); 1312} 1313 1314TEST(MemorySanitizer, swprintf) { 1315 wchar_t buff[10]; 1316 assert(sizeof(wchar_t) == 4); 1317 break_optimization(buff); 1318 EXPECT_POISONED(buff[0]); 1319 int res = swprintf(buff, 9, L"%d", 1234567); 1320 assert(res == 7); 1321 assert(buff[0] == '1'); 1322 assert(buff[1] == '2'); 1323 assert(buff[2] == '3'); 1324 assert(buff[6] == '7'); 1325 assert(buff[7] == 0); 1326 EXPECT_POISONED(buff[8]); 1327} 1328 1329TEST(MemorySanitizer, asprintf) { // NOLINT 1330 char *pbuf; 1331 EXPECT_POISONED(pbuf); 1332 int res = asprintf(&pbuf, "%d", 1234567); // NOLINT 1333 assert(res == 7); 1334 EXPECT_NOT_POISONED(pbuf); 1335 assert(pbuf[0] == '1'); 1336 assert(pbuf[1] == '2'); 1337 assert(pbuf[2] == '3'); 1338 assert(pbuf[6] == '7'); 1339 assert(pbuf[7] == 0); 1340 free(pbuf); 1341} 1342 1343TEST(MemorySanitizer, mbstowcs) { 1344 const char *x = "abc"; 1345 wchar_t buff[10]; 1346 int res = mbstowcs(buff, x, 2); 1347 EXPECT_EQ(2, res); 1348 EXPECT_EQ(L'a', buff[0]); 1349 EXPECT_EQ(L'b', buff[1]); 1350 EXPECT_POISONED(buff[2]); 1351 res = mbstowcs(buff, x, 10); 1352 EXPECT_EQ(3, res); 1353 EXPECT_NOT_POISONED(buff[3]); 1354} 1355 1356TEST(MemorySanitizer, wcstombs) { 1357 const wchar_t *x = L"abc"; 1358 char buff[10]; 1359 int res = wcstombs(buff, x, 4); 1360 EXPECT_EQ(res, 3); 1361 EXPECT_EQ(buff[0], 'a'); 1362 EXPECT_EQ(buff[1], 'b'); 1363 EXPECT_EQ(buff[2], 'c'); 1364} 1365 1366TEST(MemorySanitizer, wcsrtombs) { 1367 const wchar_t *x = L"abc"; 1368 const wchar_t *p = x; 1369 char buff[10]; 1370 mbstate_t mbs; 1371 memset(&mbs, 0, sizeof(mbs)); 1372 int res = wcsrtombs(buff, &p, 4, &mbs); 1373 EXPECT_EQ(res, 3); 1374 EXPECT_EQ(buff[0], 'a'); 1375 EXPECT_EQ(buff[1], 'b'); 1376 EXPECT_EQ(buff[2], 'c'); 1377 EXPECT_EQ(buff[3], '\0'); 1378 EXPECT_POISONED(buff[4]); 1379} 1380 1381TEST(MemorySanitizer, wcsnrtombs) { 1382 const wchar_t *x = L"abc"; 1383 const wchar_t *p = x; 1384 char buff[10]; 1385 mbstate_t mbs; 1386 memset(&mbs, 0, sizeof(mbs)); 1387 int res = wcsnrtombs(buff, &p, 2, 4, &mbs); 1388 EXPECT_EQ(res, 2); 1389 EXPECT_EQ(buff[0], 'a'); 1390 EXPECT_EQ(buff[1], 'b'); 1391 EXPECT_POISONED(buff[2]); 1392} 1393 1394TEST(MemorySanitizer, mbtowc) { 1395 const char *x = "abc"; 1396 wchar_t wx; 1397 int res = mbtowc(&wx, x, 3); 1398 EXPECT_GT(res, 0); 1399 EXPECT_NOT_POISONED(wx); 1400} 1401 1402TEST(MemorySanitizer, mbrtowc) { 1403 const char *x = "abc"; 1404 wchar_t wx; 1405 mbstate_t mbs; 1406 memset(&mbs, 0, sizeof(mbs)); 1407 int res = mbrtowc(&wx, x, 3, &mbs); 1408 EXPECT_GT(res, 0); 1409 EXPECT_NOT_POISONED(wx); 1410} 1411 1412TEST(MemorySanitizer, gettimeofday) { 1413 struct timeval tv; 1414 struct timezone tz; 1415 break_optimization(&tv); 1416 break_optimization(&tz); 1417 assert(sizeof(tv) == 16); 1418 assert(sizeof(tz) == 8); 1419 EXPECT_POISONED(tv.tv_sec); 1420 EXPECT_POISONED(tv.tv_usec); 1421 EXPECT_POISONED(tz.tz_minuteswest); 1422 EXPECT_POISONED(tz.tz_dsttime); 1423 assert(0 == gettimeofday(&tv, &tz)); 1424 EXPECT_NOT_POISONED(tv.tv_sec); 1425 EXPECT_NOT_POISONED(tv.tv_usec); 1426 EXPECT_NOT_POISONED(tz.tz_minuteswest); 1427 EXPECT_NOT_POISONED(tz.tz_dsttime); 1428} 1429 1430TEST(MemorySanitizer, clock_gettime) { 1431 struct timespec tp; 1432 EXPECT_POISONED(tp.tv_sec); 1433 EXPECT_POISONED(tp.tv_nsec); 1434 assert(0 == clock_gettime(CLOCK_REALTIME, &tp)); 1435 EXPECT_NOT_POISONED(tp.tv_sec); 1436 EXPECT_NOT_POISONED(tp.tv_nsec); 1437} 1438 1439TEST(MemorySanitizer, clock_getres) { 1440 struct timespec tp; 1441 EXPECT_POISONED(tp.tv_sec); 1442 EXPECT_POISONED(tp.tv_nsec); 1443 assert(0 == clock_getres(CLOCK_REALTIME, 0)); 1444 EXPECT_POISONED(tp.tv_sec); 1445 EXPECT_POISONED(tp.tv_nsec); 1446 assert(0 == clock_getres(CLOCK_REALTIME, &tp)); 1447 EXPECT_NOT_POISONED(tp.tv_sec); 1448 EXPECT_NOT_POISONED(tp.tv_nsec); 1449} 1450 1451TEST(MemorySanitizer, getitimer) { 1452 struct itimerval it1, it2; 1453 int res; 1454 EXPECT_POISONED(it1.it_interval.tv_sec); 1455 EXPECT_POISONED(it1.it_interval.tv_usec); 1456 EXPECT_POISONED(it1.it_value.tv_sec); 1457 EXPECT_POISONED(it1.it_value.tv_usec); 1458 res = getitimer(ITIMER_VIRTUAL, &it1); 1459 assert(!res); 1460 EXPECT_NOT_POISONED(it1.it_interval.tv_sec); 1461 EXPECT_NOT_POISONED(it1.it_interval.tv_usec); 1462 EXPECT_NOT_POISONED(it1.it_value.tv_sec); 1463 EXPECT_NOT_POISONED(it1.it_value.tv_usec); 1464 1465 it1.it_interval.tv_sec = it1.it_value.tv_sec = 10000; 1466 it1.it_interval.tv_usec = it1.it_value.tv_usec = 0; 1467 1468 res = setitimer(ITIMER_VIRTUAL, &it1, &it2); 1469 assert(!res); 1470 EXPECT_NOT_POISONED(it2.it_interval.tv_sec); 1471 EXPECT_NOT_POISONED(it2.it_interval.tv_usec); 1472 EXPECT_NOT_POISONED(it2.it_value.tv_sec); 1473 EXPECT_NOT_POISONED(it2.it_value.tv_usec); 1474 1475 // Check that old_value can be 0, and disable the timer. 1476 memset(&it1, 0, sizeof(it1)); 1477 res = setitimer(ITIMER_VIRTUAL, &it1, 0); 1478 assert(!res); 1479} 1480 1481TEST(MemorySanitizer, setitimer_null) { 1482 setitimer(ITIMER_VIRTUAL, 0, 0); 1483 // Not testing the return value, since it the behaviour seems to differ 1484 // between libc implementations and POSIX. 1485 // Should never crash, though. 1486} 1487 1488TEST(MemorySanitizer, time) { 1489 time_t t; 1490 EXPECT_POISONED(t); 1491 time_t t2 = time(&t); 1492 assert(t2 != (time_t)-1); 1493 EXPECT_NOT_POISONED(t); 1494} 1495 1496TEST(MemorySanitizer, localtime) { 1497 time_t t = 123; 1498 struct tm *time = localtime(&t); 1499 assert(time != 0); 1500 EXPECT_NOT_POISONED(time->tm_sec); 1501 EXPECT_NOT_POISONED(time->tm_hour); 1502 EXPECT_NOT_POISONED(time->tm_year); 1503 EXPECT_NOT_POISONED(time->tm_isdst); 1504} 1505 1506TEST(MemorySanitizer, localtime_r) { 1507 time_t t = 123; 1508 struct tm time; 1509 struct tm *res = localtime_r(&t, &time); 1510 assert(res != 0); 1511 EXPECT_NOT_POISONED(time.tm_sec); 1512 EXPECT_NOT_POISONED(time.tm_hour); 1513 EXPECT_NOT_POISONED(time.tm_year); 1514 EXPECT_NOT_POISONED(time.tm_isdst); 1515} 1516 1517TEST(MemorySanitizer, mmap) { 1518 const int size = 4096; 1519 void *p1, *p2; 1520 p1 = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0); 1521 __msan_poison(p1, size); 1522 munmap(p1, size); 1523 for (int i = 0; i < 1000; i++) { 1524 p2 = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0); 1525 if (p2 == p1) 1526 break; 1527 else 1528 munmap(p2, size); 1529 } 1530 if (p1 == p2) { 1531 EXPECT_NOT_POISONED(*(char*)p2); 1532 munmap(p2, size); 1533 } 1534} 1535 1536// FIXME: enable and add ecvt. 1537// FIXME: check why msandr does nt handle fcvt. 1538TEST(MemorySanitizer, fcvt) { 1539 int a, b; 1540 break_optimization(&a); 1541 break_optimization(&b); 1542 EXPECT_POISONED(a); 1543 EXPECT_POISONED(b); 1544 char *str = fcvt(12345.6789, 10, &a, &b); 1545 EXPECT_NOT_POISONED(a); 1546 EXPECT_NOT_POISONED(b); 1547} 1548 1549TEST(MemorySanitizer, frexp) { 1550 int x; 1551 x = *GetPoisoned<int>(); 1552 double r = frexp(1.1, &x); 1553 EXPECT_NOT_POISONED(r); 1554 EXPECT_NOT_POISONED(x); 1555 1556 x = *GetPoisoned<int>(); 1557 float rf = frexpf(1.1, &x); 1558 EXPECT_NOT_POISONED(rf); 1559 EXPECT_NOT_POISONED(x); 1560 1561 x = *GetPoisoned<int>(); 1562 double rl = frexpl(1.1, &x); 1563 EXPECT_NOT_POISONED(rl); 1564 EXPECT_NOT_POISONED(x); 1565} 1566 1567namespace { 1568 1569static int cnt; 1570 1571void SigactionHandler(int signo, siginfo_t* si, void* uc) { 1572 assert(signo == SIGPROF); 1573 assert(si); 1574 EXPECT_NOT_POISONED(si->si_errno); 1575 EXPECT_NOT_POISONED(si->si_pid); 1576#if __linux__ 1577# if defined(__x86_64__) 1578 EXPECT_NOT_POISONED(((ucontext_t*)uc)->uc_mcontext.gregs[REG_RIP]); 1579# elif defined(__i386__) 1580 EXPECT_NOT_POISONED(((ucontext_t*)uc)->uc_mcontext.gregs[REG_EIP]); 1581# endif 1582#endif 1583 ++cnt; 1584} 1585 1586TEST(MemorySanitizer, sigaction) { 1587 struct sigaction act = {}; 1588 struct sigaction oldact = {}; 1589 struct sigaction origact = {}; 1590 1591 sigaction(SIGPROF, 0, &origact); 1592 1593 act.sa_flags |= SA_SIGINFO; 1594 act.sa_sigaction = &SigactionHandler; 1595 sigaction(SIGPROF, &act, 0); 1596 1597 kill(getpid(), SIGPROF); 1598 1599 act.sa_flags &= ~SA_SIGINFO; 1600 act.sa_handler = SIG_DFL; 1601 sigaction(SIGPROF, &act, 0); 1602 1603 act.sa_flags &= ~SA_SIGINFO; 1604 act.sa_handler = SIG_IGN; 1605 sigaction(SIGPROF, &act, &oldact); 1606 EXPECT_FALSE(oldact.sa_flags & SA_SIGINFO); 1607 EXPECT_EQ(SIG_DFL, oldact.sa_handler); 1608 kill(getpid(), SIGPROF); 1609 1610 act.sa_flags |= SA_SIGINFO; 1611 act.sa_sigaction = &SigactionHandler; 1612 sigaction(SIGPROF, &act, &oldact); 1613 EXPECT_FALSE(oldact.sa_flags & SA_SIGINFO); 1614 EXPECT_EQ(SIG_IGN, oldact.sa_handler); 1615 kill(getpid(), SIGPROF); 1616 1617 act.sa_flags &= ~SA_SIGINFO; 1618 act.sa_handler = SIG_DFL; 1619 sigaction(SIGPROF, &act, &oldact); 1620 EXPECT_TRUE(oldact.sa_flags & SA_SIGINFO); 1621 EXPECT_EQ(&SigactionHandler, oldact.sa_sigaction); 1622 EXPECT_EQ(2, cnt); 1623 1624 sigaction(SIGPROF, &origact, 0); 1625} 1626 1627} // namespace 1628 1629struct StructWithDtor { 1630 ~StructWithDtor(); 1631}; 1632 1633NOINLINE StructWithDtor::~StructWithDtor() { 1634 break_optimization(0); 1635} 1636 1637TEST(MemorySanitizer, Invoke) { 1638 StructWithDtor s; // Will cause the calls to become invokes. 1639 EXPECT_NOT_POISONED(0); 1640 EXPECT_POISONED(*GetPoisoned<int>()); 1641 EXPECT_NOT_POISONED(0); 1642 EXPECT_POISONED(*GetPoisoned<int>()); 1643 EXPECT_POISONED(ReturnPoisoned<S4>()); 1644} 1645 1646TEST(MemorySanitizer, ptrtoint) { 1647 // Test that shadow is propagated through pointer-to-integer conversion. 1648 void* p = (void*)0xABCD; 1649 __msan_poison(((char*)&p) + 1, sizeof(p)); 1650 EXPECT_NOT_POISONED((((uintptr_t)p) & 0xFF) == 0); 1651 1652 void* q = (void*)0xABCD; 1653 __msan_poison(&q, sizeof(q) - 1); 1654 EXPECT_POISONED((((uintptr_t)q) & 0xFF) == 0); 1655} 1656 1657static void vaargsfn2(int guard, ...) { 1658 va_list vl; 1659 va_start(vl, guard); 1660 EXPECT_NOT_POISONED(va_arg(vl, int)); 1661 EXPECT_NOT_POISONED(va_arg(vl, int)); 1662 EXPECT_NOT_POISONED(va_arg(vl, int)); 1663 EXPECT_POISONED(va_arg(vl, double)); 1664 va_end(vl); 1665} 1666 1667static void vaargsfn(int guard, ...) { 1668 va_list vl; 1669 va_start(vl, guard); 1670 EXPECT_NOT_POISONED(va_arg(vl, int)); 1671 EXPECT_POISONED(va_arg(vl, int)); 1672 // The following call will overwrite __msan_param_tls. 1673 // Checks after it test that arg shadow was somehow saved across the call. 1674 vaargsfn2(1, 2, 3, 4, *GetPoisoned<double>()); 1675 EXPECT_NOT_POISONED(va_arg(vl, int)); 1676 EXPECT_POISONED(va_arg(vl, int)); 1677 va_end(vl); 1678} 1679 1680TEST(MemorySanitizer, VAArgTest) { 1681 int* x = GetPoisoned<int>(); 1682 int* y = GetPoisoned<int>(4); 1683 vaargsfn(1, 13, *x, 42, *y); 1684} 1685 1686static void vaargsfn_many(int guard, ...) { 1687 va_list vl; 1688 va_start(vl, guard); 1689 EXPECT_NOT_POISONED(va_arg(vl, int)); 1690 EXPECT_POISONED(va_arg(vl, int)); 1691 EXPECT_NOT_POISONED(va_arg(vl, int)); 1692 EXPECT_NOT_POISONED(va_arg(vl, int)); 1693 EXPECT_NOT_POISONED(va_arg(vl, int)); 1694 EXPECT_NOT_POISONED(va_arg(vl, int)); 1695 EXPECT_NOT_POISONED(va_arg(vl, int)); 1696 EXPECT_NOT_POISONED(va_arg(vl, int)); 1697 EXPECT_NOT_POISONED(va_arg(vl, int)); 1698 EXPECT_POISONED(va_arg(vl, int)); 1699 va_end(vl); 1700} 1701 1702TEST(MemorySanitizer, VAArgManyTest) { 1703 int* x = GetPoisoned<int>(); 1704 int* y = GetPoisoned<int>(4); 1705 vaargsfn_many(1, 2, *x, 3, 4, 5, 6, 7, 8, 9, *y); 1706} 1707 1708static void vaargsfn_pass2(va_list vl) { 1709 EXPECT_NOT_POISONED(va_arg(vl, int)); 1710 EXPECT_NOT_POISONED(va_arg(vl, int)); 1711 EXPECT_POISONED(va_arg(vl, int)); 1712} 1713 1714static void vaargsfn_pass(int guard, ...) { 1715 va_list vl; 1716 va_start(vl, guard); 1717 EXPECT_POISONED(va_arg(vl, int)); 1718 vaargsfn_pass2(vl); 1719 va_end(vl); 1720} 1721 1722TEST(MemorySanitizer, VAArgPass) { 1723 int* x = GetPoisoned<int>(); 1724 int* y = GetPoisoned<int>(4); 1725 vaargsfn_pass(1, *x, 2, 3, *y); 1726} 1727 1728static void vaargsfn_copy2(va_list vl) { 1729 EXPECT_NOT_POISONED(va_arg(vl, int)); 1730 EXPECT_POISONED(va_arg(vl, int)); 1731} 1732 1733static void vaargsfn_copy(int guard, ...) { 1734 va_list vl; 1735 va_start(vl, guard); 1736 EXPECT_NOT_POISONED(va_arg(vl, int)); 1737 EXPECT_POISONED(va_arg(vl, int)); 1738 va_list vl2; 1739 va_copy(vl2, vl); 1740 vaargsfn_copy2(vl2); 1741 EXPECT_NOT_POISONED(va_arg(vl, int)); 1742 EXPECT_POISONED(va_arg(vl, int)); 1743 va_end(vl); 1744} 1745 1746TEST(MemorySanitizer, VAArgCopy) { 1747 int* x = GetPoisoned<int>(); 1748 int* y = GetPoisoned<int>(4); 1749 vaargsfn_copy(1, 2, *x, 3, *y); 1750} 1751 1752static void vaargsfn_ptr(int guard, ...) { 1753 va_list vl; 1754 va_start(vl, guard); 1755 EXPECT_NOT_POISONED(va_arg(vl, int*)); 1756 EXPECT_POISONED(va_arg(vl, int*)); 1757 EXPECT_NOT_POISONED(va_arg(vl, int*)); 1758 EXPECT_POISONED(va_arg(vl, double*)); 1759 va_end(vl); 1760} 1761 1762TEST(MemorySanitizer, VAArgPtr) { 1763 int** x = GetPoisoned<int*>(); 1764 double** y = GetPoisoned<double*>(8); 1765 int z; 1766 vaargsfn_ptr(1, &z, *x, &z, *y); 1767} 1768 1769static void vaargsfn_overflow(int guard, ...) { 1770 va_list vl; 1771 va_start(vl, guard); 1772 EXPECT_NOT_POISONED(va_arg(vl, int)); 1773 EXPECT_NOT_POISONED(va_arg(vl, int)); 1774 EXPECT_POISONED(va_arg(vl, int)); 1775 EXPECT_NOT_POISONED(va_arg(vl, int)); 1776 EXPECT_NOT_POISONED(va_arg(vl, int)); 1777 EXPECT_NOT_POISONED(va_arg(vl, int)); 1778 1779 EXPECT_NOT_POISONED(va_arg(vl, double)); 1780 EXPECT_NOT_POISONED(va_arg(vl, double)); 1781 EXPECT_NOT_POISONED(va_arg(vl, double)); 1782 EXPECT_POISONED(va_arg(vl, double)); 1783 EXPECT_NOT_POISONED(va_arg(vl, double)); 1784 EXPECT_POISONED(va_arg(vl, int*)); 1785 EXPECT_NOT_POISONED(va_arg(vl, double)); 1786 EXPECT_NOT_POISONED(va_arg(vl, double)); 1787 1788 EXPECT_POISONED(va_arg(vl, int)); 1789 EXPECT_POISONED(va_arg(vl, double)); 1790 EXPECT_POISONED(va_arg(vl, int*)); 1791 1792 EXPECT_NOT_POISONED(va_arg(vl, int)); 1793 EXPECT_NOT_POISONED(va_arg(vl, double)); 1794 EXPECT_NOT_POISONED(va_arg(vl, int*)); 1795 1796 EXPECT_POISONED(va_arg(vl, int)); 1797 EXPECT_POISONED(va_arg(vl, double)); 1798 EXPECT_POISONED(va_arg(vl, int*)); 1799 1800 va_end(vl); 1801} 1802 1803TEST(MemorySanitizer, VAArgOverflow) { 1804 int* x = GetPoisoned<int>(); 1805 double* y = GetPoisoned<double>(8); 1806 int** p = GetPoisoned<int*>(16); 1807 int z; 1808 vaargsfn_overflow(1, 1809 1, 2, *x, 4, 5, 6, 1810 1.1, 2.2, 3.3, *y, 5.5, *p, 7.7, 8.8, 1811 // the following args will overflow for sure 1812 *x, *y, *p, 1813 7, 9.9, &z, 1814 *x, *y, *p); 1815} 1816 1817static void vaargsfn_tlsoverwrite2(int guard, ...) { 1818 va_list vl; 1819 va_start(vl, guard); 1820 for (int i = 0; i < 20; ++i) 1821 EXPECT_NOT_POISONED(va_arg(vl, int)); 1822 va_end(vl); 1823} 1824 1825static void vaargsfn_tlsoverwrite(int guard, ...) { 1826 // This call will overwrite TLS contents unless it's backed up somewhere. 1827 vaargsfn_tlsoverwrite2(2, 1828 42, 42, 42, 42, 42, 1829 42, 42, 42, 42, 42, 1830 42, 42, 42, 42, 42, 1831 42, 42, 42, 42, 42); // 20x 1832 va_list vl; 1833 va_start(vl, guard); 1834 for (int i = 0; i < 20; ++i) 1835 EXPECT_POISONED(va_arg(vl, int)); 1836 va_end(vl); 1837} 1838 1839TEST(MemorySanitizer, VAArgTLSOverwrite) { 1840 int* x = GetPoisoned<int>(); 1841 vaargsfn_tlsoverwrite(1, 1842 *x, *x, *x, *x, *x, 1843 *x, *x, *x, *x, *x, 1844 *x, *x, *x, *x, *x, 1845 *x, *x, *x, *x, *x); // 20x 1846 1847} 1848 1849struct StructByVal { 1850 int a, b, c, d, e, f; 1851}; 1852 1853NOINLINE void StructByValTestFunc(struct StructByVal s) { 1854 EXPECT_NOT_POISONED(s.a); 1855 EXPECT_POISONED(s.b); 1856 EXPECT_NOT_POISONED(s.c); 1857 EXPECT_POISONED(s.d); 1858 EXPECT_NOT_POISONED(s.e); 1859 EXPECT_POISONED(s.f); 1860} 1861 1862NOINLINE void StructByValTestFunc1(struct StructByVal s) { 1863 StructByValTestFunc(s); 1864} 1865 1866NOINLINE void StructByValTestFunc2(int z, struct StructByVal s) { 1867 StructByValTestFunc(s); 1868} 1869 1870TEST(MemorySanitizer, StructByVal) { 1871 // Large aggregates are passed as "byval" pointer argument in LLVM. 1872 struct StructByVal s; 1873 s.a = 1; 1874 s.b = *GetPoisoned<int>(); 1875 s.c = 2; 1876 s.d = *GetPoisoned<int>(); 1877 s.e = 3; 1878 s.f = *GetPoisoned<int>(); 1879 StructByValTestFunc(s); 1880 StructByValTestFunc1(s); 1881 StructByValTestFunc2(0, s); 1882} 1883 1884 1885#if MSAN_HAS_M128 1886NOINLINE __m128i m128Eq(__m128i *a, __m128i *b) { return _mm_cmpeq_epi16(*a, *b); } 1887NOINLINE __m128i m128Lt(__m128i *a, __m128i *b) { return _mm_cmplt_epi16(*a, *b); } 1888TEST(MemorySanitizer, m128) { 1889 __m128i a = _mm_set1_epi16(0x1234); 1890 __m128i b = _mm_set1_epi16(0x7890); 1891 EXPECT_NOT_POISONED(m128Eq(&a, &b)); 1892 EXPECT_NOT_POISONED(m128Lt(&a, &b)); 1893} 1894// FIXME: add more tests for __m128i. 1895#endif // MSAN_HAS_M128 1896 1897// We should not complain when copying this poisoned hole. 1898struct StructWithHole { 1899 U4 a; 1900 // 4-byte hole. 1901 U8 b; 1902}; 1903 1904NOINLINE StructWithHole ReturnStructWithHole() { 1905 StructWithHole res; 1906 __msan_poison(&res, sizeof(res)); 1907 res.a = 1; 1908 res.b = 2; 1909 return res; 1910} 1911 1912TEST(MemorySanitizer, StructWithHole) { 1913 StructWithHole a = ReturnStructWithHole(); 1914 break_optimization(&a); 1915} 1916 1917template <class T> 1918NOINLINE T ReturnStruct() { 1919 T res; 1920 __msan_poison(&res, sizeof(res)); 1921 res.a = 1; 1922 return res; 1923} 1924 1925template <class T> 1926NOINLINE void TestReturnStruct() { 1927 T s1 = ReturnStruct<T>(); 1928 EXPECT_NOT_POISONED(s1.a); 1929 EXPECT_POISONED(s1.b); 1930} 1931 1932struct SSS1 { 1933 int a, b, c; 1934}; 1935struct SSS2 { 1936 int b, a, c; 1937}; 1938struct SSS3 { 1939 int b, c, a; 1940}; 1941struct SSS4 { 1942 int c, b, a; 1943}; 1944 1945struct SSS5 { 1946 int a; 1947 float b; 1948}; 1949struct SSS6 { 1950 int a; 1951 double b; 1952}; 1953struct SSS7 { 1954 S8 b; 1955 int a; 1956}; 1957struct SSS8 { 1958 S2 b; 1959 S8 a; 1960}; 1961 1962TEST(MemorySanitizer, IntStruct3) { 1963 TestReturnStruct<SSS1>(); 1964 TestReturnStruct<SSS2>(); 1965 TestReturnStruct<SSS3>(); 1966 TestReturnStruct<SSS4>(); 1967 TestReturnStruct<SSS5>(); 1968 TestReturnStruct<SSS6>(); 1969 TestReturnStruct<SSS7>(); 1970 TestReturnStruct<SSS8>(); 1971} 1972 1973struct LongStruct { 1974 U1 a1, b1; 1975 U2 a2, b2; 1976 U4 a4, b4; 1977 U8 a8, b8; 1978}; 1979 1980NOINLINE LongStruct ReturnLongStruct1() { 1981 LongStruct res; 1982 __msan_poison(&res, sizeof(res)); 1983 res.a1 = res.a2 = res.a4 = res.a8 = 111; 1984 // leaves b1, .., b8 poisoned. 1985 return res; 1986} 1987 1988NOINLINE LongStruct ReturnLongStruct2() { 1989 LongStruct res; 1990 __msan_poison(&res, sizeof(res)); 1991 res.b1 = res.b2 = res.b4 = res.b8 = 111; 1992 // leaves a1, .., a8 poisoned. 1993 return res; 1994} 1995 1996TEST(MemorySanitizer, LongStruct) { 1997 LongStruct s1 = ReturnLongStruct1(); 1998 __msan_print_shadow(&s1, sizeof(s1)); 1999 EXPECT_NOT_POISONED(s1.a1); 2000 EXPECT_NOT_POISONED(s1.a2); 2001 EXPECT_NOT_POISONED(s1.a4); 2002 EXPECT_NOT_POISONED(s1.a8); 2003 2004 EXPECT_POISONED(s1.b1); 2005 EXPECT_POISONED(s1.b2); 2006 EXPECT_POISONED(s1.b4); 2007 EXPECT_POISONED(s1.b8); 2008 2009 LongStruct s2 = ReturnLongStruct2(); 2010 __msan_print_shadow(&s2, sizeof(s2)); 2011 EXPECT_NOT_POISONED(s2.b1); 2012 EXPECT_NOT_POISONED(s2.b2); 2013 EXPECT_NOT_POISONED(s2.b4); 2014 EXPECT_NOT_POISONED(s2.b8); 2015 2016 EXPECT_POISONED(s2.a1); 2017 EXPECT_POISONED(s2.a2); 2018 EXPECT_POISONED(s2.a4); 2019 EXPECT_POISONED(s2.a8); 2020} 2021 2022TEST(MemorySanitizer, getrlimit) { 2023 struct rlimit limit; 2024 __msan_poison(&limit, sizeof(limit)); 2025 int result = getrlimit(RLIMIT_DATA, &limit); 2026 assert(result == 0); 2027 EXPECT_NOT_POISONED(limit.rlim_cur); 2028 EXPECT_NOT_POISONED(limit.rlim_max); 2029} 2030 2031TEST(MemorySanitizer, getrusage) { 2032 struct rusage usage; 2033 __msan_poison(&usage, sizeof(usage)); 2034 int result = getrusage(RUSAGE_SELF, &usage); 2035 assert(result == 0); 2036 EXPECT_NOT_POISONED(usage.ru_utime.tv_sec); 2037 EXPECT_NOT_POISONED(usage.ru_utime.tv_usec); 2038 EXPECT_NOT_POISONED(usage.ru_stime.tv_sec); 2039 EXPECT_NOT_POISONED(usage.ru_stime.tv_usec); 2040 EXPECT_NOT_POISONED(usage.ru_maxrss); 2041 EXPECT_NOT_POISONED(usage.ru_minflt); 2042 EXPECT_NOT_POISONED(usage.ru_majflt); 2043 EXPECT_NOT_POISONED(usage.ru_inblock); 2044 EXPECT_NOT_POISONED(usage.ru_oublock); 2045 EXPECT_NOT_POISONED(usage.ru_nvcsw); 2046 EXPECT_NOT_POISONED(usage.ru_nivcsw); 2047} 2048 2049#ifdef __GLIBC__ 2050extern char *program_invocation_name; 2051#else // __GLIBC__ 2052# error "TODO: port this" 2053#endif 2054 2055static void dladdr_testfn() {} 2056 2057TEST(MemorySanitizer, dladdr) { 2058 Dl_info info; 2059 __msan_poison(&info, sizeof(info)); 2060 int result = dladdr((const void*)dladdr_testfn, &info); 2061 assert(result != 0); 2062 EXPECT_NOT_POISONED((unsigned long)info.dli_fname); 2063 if (info.dli_fname) 2064 EXPECT_NOT_POISONED(strlen(info.dli_fname)); 2065 EXPECT_NOT_POISONED((unsigned long)info.dli_fbase); 2066 EXPECT_NOT_POISONED((unsigned long)info.dli_sname); 2067 if (info.dli_sname) 2068 EXPECT_NOT_POISONED(strlen(info.dli_sname)); 2069 EXPECT_NOT_POISONED((unsigned long)info.dli_saddr); 2070} 2071 2072#ifndef MSAN_TEST_DISABLE_DLOPEN 2073 2074static int dl_phdr_callback(struct dl_phdr_info *info, size_t size, void *data) { 2075 (*(int *)data)++; 2076 EXPECT_NOT_POISONED(info->dlpi_addr); 2077 EXPECT_NOT_POISONED(strlen(info->dlpi_name)); 2078 EXPECT_NOT_POISONED(info->dlpi_phnum); 2079 for (int i = 0; i < info->dlpi_phnum; ++i) 2080 EXPECT_NOT_POISONED(info->dlpi_phdr[i]); 2081 return 0; 2082} 2083 2084// Compute the path to our loadable DSO. We assume it's in the same 2085// directory. Only use string routines that we intercept so far to do this. 2086static int PathToLoadable(char *buf, size_t sz) { 2087 const char *basename = "libmsan_loadable.x86_64.so"; 2088 char *argv0 = program_invocation_name; 2089 char *last_slash = strrchr(argv0, '/'); 2090 assert(last_slash); 2091 int res = 2092 snprintf(buf, sz, "%.*s/%s", int(last_slash - argv0), argv0, basename); 2093 return res < sz ? 0 : res; 2094} 2095 2096TEST(MemorySanitizer, dl_iterate_phdr) { 2097 char path[4096]; 2098 int res = PathToLoadable(path, sizeof(path)); 2099 assert(!res); 2100 2101 // Having at least one dlopen'ed library in the process makes this more 2102 // entertaining. 2103 void *lib = dlopen(path, RTLD_LAZY); 2104 ASSERT_NE((void*)0, lib); 2105 2106 int count = 0; 2107 int result = dl_iterate_phdr(dl_phdr_callback, &count); 2108 assert(count > 0); 2109 2110 dlclose(lib); 2111} 2112 2113 2114TEST(MemorySanitizer, dlopen) { 2115 char path[4096]; 2116 int res = PathToLoadable(path, sizeof(path)); 2117 assert(!res); 2118 2119 // We need to clear shadow for globals when doing dlopen. In order to test 2120 // this, we have to poison the shadow for the DSO before we load it. In 2121 // general this is difficult, but the loader tends to reload things in the 2122 // same place, so we open, close, and then reopen. The global should always 2123 // start out clean after dlopen. 2124 for (int i = 0; i < 2; i++) { 2125 void *lib = dlopen(path, RTLD_LAZY); 2126 if (lib == NULL) { 2127 printf("dlerror: %s\n", dlerror()); 2128 assert(lib != NULL); 2129 } 2130 void **(*get_dso_global)() = (void **(*)())dlsym(lib, "get_dso_global"); 2131 assert(get_dso_global); 2132 void **dso_global = get_dso_global(); 2133 EXPECT_NOT_POISONED(*dso_global); 2134 __msan_poison(dso_global, sizeof(*dso_global)); 2135 EXPECT_POISONED(*dso_global); 2136 dlclose(lib); 2137 } 2138} 2139 2140// Regression test for a crash in dlopen() interceptor. 2141TEST(MemorySanitizer, dlopenFailed) { 2142 const char *path = "/libmsan_loadable_does_not_exist.x86_64.so"; 2143 void *lib = dlopen(path, RTLD_LAZY); 2144 ASSERT_EQ(0, lib); 2145} 2146 2147#endif // MSAN_TEST_DISABLE_DLOPEN 2148 2149TEST(MemorySanitizer, sched_getaffinity) { 2150 cpu_set_t mask; 2151 int res = sched_getaffinity(getpid(), sizeof(mask), &mask); 2152 ASSERT_EQ(0, res); 2153 EXPECT_NOT_POISONED(mask); 2154} 2155 2156TEST(MemorySanitizer, scanf) { 2157 const char *input = "42 hello"; 2158 int* d = new int; 2159 char* s = new char[7]; 2160 int res = sscanf(input, "%d %5s", d, s); 2161 printf("res %d\n", res); 2162 assert(res == 2); 2163 EXPECT_NOT_POISONED(*d); 2164 EXPECT_NOT_POISONED(s[0]); 2165 EXPECT_NOT_POISONED(s[1]); 2166 EXPECT_NOT_POISONED(s[2]); 2167 EXPECT_NOT_POISONED(s[3]); 2168 EXPECT_NOT_POISONED(s[4]); 2169 EXPECT_NOT_POISONED(s[5]); 2170 EXPECT_POISONED(s[6]); 2171 delete s; 2172 delete d; 2173} 2174 2175static void *SimpleThread_threadfn(void* data) { 2176 return new int; 2177} 2178 2179TEST(MemorySanitizer, SimpleThread) { 2180 pthread_t t; 2181 void *p; 2182 int res = pthread_create(&t, NULL, SimpleThread_threadfn, NULL); 2183 assert(!res); 2184 EXPECT_NOT_POISONED(t); 2185 res = pthread_join(t, &p); 2186 assert(!res); 2187 EXPECT_NOT_POISONED(p); 2188 delete (int*)p; 2189} 2190 2191static void *SmallStackThread_threadfn(void* data) { 2192 return 0; 2193} 2194 2195TEST(MemorySanitizer, SmallStackThread) { 2196 pthread_attr_t attr; 2197 pthread_t t; 2198 void *p; 2199 int res; 2200 res = pthread_attr_init(&attr); 2201 ASSERT_EQ(0, res); 2202 res = pthread_attr_setstacksize(&attr, 64 * 1024); 2203 ASSERT_EQ(0, res); 2204 res = pthread_create(&t, &attr, SmallStackThread_threadfn, NULL); 2205 ASSERT_EQ(0, res); 2206 res = pthread_join(t, &p); 2207 ASSERT_EQ(0, res); 2208 res = pthread_attr_destroy(&attr); 2209 ASSERT_EQ(0, res); 2210} 2211 2212TEST(MemorySanitizer, PreAllocatedStackThread) { 2213 pthread_attr_t attr; 2214 pthread_t t; 2215 int res; 2216 res = pthread_attr_init(&attr); 2217 ASSERT_EQ(0, res); 2218 void *stack; 2219 const size_t kStackSize = 64 * 1024; 2220 res = posix_memalign(&stack, 4096, kStackSize); 2221 ASSERT_EQ(0, res); 2222 res = pthread_attr_setstack(&attr, stack, kStackSize); 2223 ASSERT_EQ(0, res); 2224 // A small self-allocated stack can not be extended by the tool. 2225 // In this case pthread_create is expected to fail. 2226 res = pthread_create(&t, &attr, SmallStackThread_threadfn, NULL); 2227 EXPECT_NE(0, res); 2228 res = pthread_attr_destroy(&attr); 2229 ASSERT_EQ(0, res); 2230} 2231 2232TEST(MemorySanitizer, pthread_getschedparam) { 2233 int policy; 2234 struct sched_param param; 2235 int res = pthread_getschedparam(pthread_self(), &policy, ¶m); 2236 ASSERT_EQ(0, res); 2237 EXPECT_NOT_POISONED(policy); 2238 EXPECT_NOT_POISONED(param.sched_priority); 2239} 2240 2241TEST(MemorySanitizer, pthread_key_create) { 2242 pthread_key_t key; 2243 int res = pthread_key_create(&key, NULL); 2244 assert(!res); 2245 EXPECT_NOT_POISONED(key); 2246 res = pthread_key_delete(key); 2247 assert(!res); 2248} 2249 2250TEST(MemorySanitizer, posix_memalign) { 2251 void *p; 2252 EXPECT_POISONED(p); 2253 int res = posix_memalign(&p, 4096, 13); 2254 ASSERT_EQ(0, res); 2255 EXPECT_NOT_POISONED(p); 2256 free(p); 2257} 2258 2259TEST(MemorySanitizer, inet_pton) { 2260 const char *s = "1:0:0:0:0:0:0:8"; 2261 unsigned char buf[sizeof(struct in6_addr)]; 2262 int res = inet_pton(AF_INET6, s, buf); 2263 ASSERT_EQ(1, res); 2264 EXPECT_NOT_POISONED(buf[0]); 2265 EXPECT_NOT_POISONED(buf[sizeof(struct in6_addr) - 1]); 2266 2267 char s_out[INET6_ADDRSTRLEN]; 2268 EXPECT_POISONED(s_out[3]); 2269 const char *q = inet_ntop(AF_INET6, buf, s_out, INET6_ADDRSTRLEN); 2270 ASSERT_NE((void*)0, q); 2271 EXPECT_NOT_POISONED(s_out[3]); 2272} 2273 2274TEST(MemorySanitizer, inet_aton) { 2275 const char *s = "127.0.0.1"; 2276 struct in_addr in[2]; 2277 int res = inet_aton(s, in); 2278 ASSERT_NE(0, res); 2279 EXPECT_NOT_POISONED(in[0]); 2280 EXPECT_POISONED(*(char *)(in + 1)); 2281} 2282 2283TEST(MemorySanitizer, uname) { 2284 struct utsname u; 2285 int res = uname(&u); 2286 assert(!res); 2287 EXPECT_NOT_POISONED(strlen(u.sysname)); 2288 EXPECT_NOT_POISONED(strlen(u.nodename)); 2289 EXPECT_NOT_POISONED(strlen(u.release)); 2290 EXPECT_NOT_POISONED(strlen(u.version)); 2291 EXPECT_NOT_POISONED(strlen(u.machine)); 2292} 2293 2294TEST(MemorySanitizer, gethostname) { 2295 char buf[100]; 2296 int res = gethostname(buf, 100); 2297 assert(!res); 2298 EXPECT_NOT_POISONED(strlen(buf)); 2299} 2300 2301TEST(MemorySanitizer, sysinfo) { 2302 struct sysinfo info; 2303 int res = sysinfo(&info); 2304 assert(!res); 2305 EXPECT_NOT_POISONED(info); 2306} 2307 2308TEST(MemorySanitizer, getpwuid) { 2309 struct passwd *p = getpwuid(0); // root 2310 assert(p); 2311 EXPECT_NOT_POISONED(p->pw_name); 2312 assert(p->pw_name); 2313 EXPECT_NOT_POISONED(p->pw_name[0]); 2314 EXPECT_NOT_POISONED(p->pw_uid); 2315 assert(p->pw_uid == 0); 2316} 2317 2318TEST(MemorySanitizer, getpwnam_r) { 2319 struct passwd pwd; 2320 struct passwd *pwdres; 2321 char buf[10000]; 2322 int res = getpwnam_r("root", &pwd, buf, sizeof(buf), &pwdres); 2323 assert(!res); 2324 EXPECT_NOT_POISONED(pwd.pw_name); 2325 assert(pwd.pw_name); 2326 EXPECT_NOT_POISONED(pwd.pw_name[0]); 2327 EXPECT_NOT_POISONED(pwd.pw_uid); 2328 assert(pwd.pw_uid == 0); 2329} 2330 2331TEST(MemorySanitizer, getpwnam_r_positive) { 2332 struct passwd pwd; 2333 struct passwd *pwdres; 2334 char s[5]; 2335 strncpy(s, "abcd", 5); 2336 __msan_poison(s, 5); 2337 char buf[10000]; 2338 int res; 2339 EXPECT_UMR(res = getpwnam_r(s, &pwd, buf, sizeof(buf), &pwdres)); 2340} 2341 2342TEST(MemorySanitizer, getgrnam_r) { 2343 struct group grp; 2344 struct group *grpres; 2345 char buf[10000]; 2346 int res = getgrnam_r("root", &grp, buf, sizeof(buf), &grpres); 2347 assert(!res); 2348 EXPECT_NOT_POISONED(grp.gr_name); 2349 assert(grp.gr_name); 2350 EXPECT_NOT_POISONED(grp.gr_name[0]); 2351 EXPECT_NOT_POISONED(grp.gr_gid); 2352} 2353 2354TEST(MemorySanitizer, getgroups) { 2355 int n = getgroups(0, 0); 2356 gid_t *gids = new gid_t[n]; 2357 int res = getgroups(n, gids); 2358 ASSERT_EQ(n, res); 2359 for (int i = 0; i < n; ++i) 2360 EXPECT_NOT_POISONED(gids[i]); 2361} 2362 2363template<class T> 2364static bool applySlt(T value, T shadow) { 2365 __msan_partial_poison(&value, &shadow, sizeof(T)); 2366 volatile bool zzz = true; 2367 // This "|| zzz" trick somehow makes LLVM emit "icmp slt" instead of 2368 // a shift-and-trunc to get at the highest bit. 2369 volatile bool v = value < 0 || zzz; 2370 return v; 2371} 2372 2373TEST(MemorySanitizer, SignedCompareWithZero) { 2374 EXPECT_NOT_POISONED(applySlt<S4>(0xF, 0xF)); 2375 EXPECT_NOT_POISONED(applySlt<S4>(0xF, 0xFF)); 2376 EXPECT_NOT_POISONED(applySlt<S4>(0xF, 0xFFFFFF)); 2377 EXPECT_NOT_POISONED(applySlt<S4>(0xF, 0x7FFFFFF)); 2378 EXPECT_UMR(applySlt<S4>(0xF, 0x80FFFFFF)); 2379 EXPECT_UMR(applySlt<S4>(0xF, 0xFFFFFFFF)); 2380} 2381 2382template <class T, class S> 2383static T poisoned(T Va, S Sa) { 2384 char SIZE_CHECK1[(ssize_t)sizeof(T) - (ssize_t)sizeof(S)]; 2385 char SIZE_CHECK2[(ssize_t)sizeof(S) - (ssize_t)sizeof(T)]; 2386 T a; 2387 a = Va; 2388 __msan_partial_poison(&a, &Sa, sizeof(T)); 2389 return a; 2390} 2391 2392TEST(MemorySanitizer, ICmpRelational) { 2393 EXPECT_NOT_POISONED(poisoned(0, 0) < poisoned(0, 0)); 2394 EXPECT_NOT_POISONED(poisoned(0U, 0) < poisoned(0U, 0)); 2395 EXPECT_NOT_POISONED(poisoned(0LL, 0LLU) < poisoned(0LL, 0LLU)); 2396 EXPECT_NOT_POISONED(poisoned(0LLU, 0LLU) < poisoned(0LLU, 0LLU)); 2397 EXPECT_POISONED(poisoned(0xFF, 0xFF) < poisoned(0xFF, 0xFF)); 2398 EXPECT_POISONED(poisoned(0xFFFFFFFFU, 0xFFFFFFFFU) < 2399 poisoned(0xFFFFFFFFU, 0xFFFFFFFFU)); 2400 EXPECT_POISONED(poisoned(-1, 0xFFFFFFFFU) < 2401 poisoned(-1, 0xFFFFFFFFU)); 2402 2403 EXPECT_NOT_POISONED(poisoned(0, 0) <= poisoned(0, 0)); 2404 EXPECT_NOT_POISONED(poisoned(0U, 0) <= poisoned(0U, 0)); 2405 EXPECT_NOT_POISONED(poisoned(0LL, 0LLU) <= poisoned(0LL, 0LLU)); 2406 EXPECT_NOT_POISONED(poisoned(0LLU, 0LLU) <= poisoned(0LLU, 0LLU)); 2407 EXPECT_POISONED(poisoned(0xFF, 0xFF) <= poisoned(0xFF, 0xFF)); 2408 EXPECT_POISONED(poisoned(0xFFFFFFFFU, 0xFFFFFFFFU) <= 2409 poisoned(0xFFFFFFFFU, 0xFFFFFFFFU)); 2410 EXPECT_POISONED(poisoned(-1, 0xFFFFFFFFU) <= 2411 poisoned(-1, 0xFFFFFFFFU)); 2412 2413 EXPECT_NOT_POISONED(poisoned(0, 0) > poisoned(0, 0)); 2414 EXPECT_NOT_POISONED(poisoned(0U, 0) > poisoned(0U, 0)); 2415 EXPECT_NOT_POISONED(poisoned(0LL, 0LLU) > poisoned(0LL, 0LLU)); 2416 EXPECT_NOT_POISONED(poisoned(0LLU, 0LLU) > poisoned(0LLU, 0LLU)); 2417 EXPECT_POISONED(poisoned(0xFF, 0xFF) > poisoned(0xFF, 0xFF)); 2418 EXPECT_POISONED(poisoned(0xFFFFFFFFU, 0xFFFFFFFFU) > 2419 poisoned(0xFFFFFFFFU, 0xFFFFFFFFU)); 2420 EXPECT_POISONED(poisoned(-1, 0xFFFFFFFFU) > 2421 poisoned(-1, 0xFFFFFFFFU)); 2422 2423 EXPECT_NOT_POISONED(poisoned(0, 0) >= poisoned(0, 0)); 2424 EXPECT_NOT_POISONED(poisoned(0U, 0) >= poisoned(0U, 0)); 2425 EXPECT_NOT_POISONED(poisoned(0LL, 0LLU) >= poisoned(0LL, 0LLU)); 2426 EXPECT_NOT_POISONED(poisoned(0LLU, 0LLU) >= poisoned(0LLU, 0LLU)); 2427 EXPECT_POISONED(poisoned(0xFF, 0xFF) >= poisoned(0xFF, 0xFF)); 2428 EXPECT_POISONED(poisoned(0xFFFFFFFFU, 0xFFFFFFFFU) >= 2429 poisoned(0xFFFFFFFFU, 0xFFFFFFFFU)); 2430 EXPECT_POISONED(poisoned(-1, 0xFFFFFFFFU) >= 2431 poisoned(-1, 0xFFFFFFFFU)); 2432 2433 EXPECT_POISONED(poisoned(6, 0xF) > poisoned(7, 0)); 2434 EXPECT_POISONED(poisoned(0xF, 0xF) > poisoned(7, 0)); 2435 2436 EXPECT_NOT_POISONED(poisoned(-1, 0x80000000U) >= poisoned(-1, 0U)); 2437} 2438 2439#if MSAN_HAS_M128 2440TEST(MemorySanitizer, ICmpVectorRelational) { 2441 EXPECT_NOT_POISONED( 2442 _mm_cmplt_epi16(poisoned(_mm_set1_epi16(0), _mm_set1_epi16(0)), 2443 poisoned(_mm_set1_epi16(0), _mm_set1_epi16(0)))); 2444 EXPECT_NOT_POISONED( 2445 _mm_cmplt_epi16(poisoned(_mm_set1_epi32(0), _mm_set1_epi32(0)), 2446 poisoned(_mm_set1_epi32(0), _mm_set1_epi32(0)))); 2447 EXPECT_POISONED( 2448 _mm_cmplt_epi16(poisoned(_mm_set1_epi16(0), _mm_set1_epi16(0xFFFF)), 2449 poisoned(_mm_set1_epi16(0), _mm_set1_epi16(0xFFFF)))); 2450 EXPECT_POISONED(_mm_cmpgt_epi16(poisoned(_mm_set1_epi16(6), _mm_set1_epi16(0xF)), 2451 poisoned(_mm_set1_epi16(7), _mm_set1_epi16(0)))); 2452} 2453#endif 2454 2455// Volatile bitfield store is implemented as load-mask-store 2456// Test that we don't warn on the store of (uninitialized) padding. 2457struct VolatileBitfieldStruct { 2458 volatile unsigned x : 1; 2459 unsigned y : 1; 2460}; 2461 2462TEST(MemorySanitizer, VolatileBitfield) { 2463 VolatileBitfieldStruct *S = new VolatileBitfieldStruct; 2464 S->x = 1; 2465 EXPECT_NOT_POISONED((unsigned)S->x); 2466 EXPECT_POISONED((unsigned)S->y); 2467} 2468 2469TEST(MemorySanitizer, UnalignedLoad) { 2470 char x[32]; 2471 memset(x + 8, 0, 16); 2472 EXPECT_POISONED(__sanitizer_unaligned_load16(x+6)); 2473 EXPECT_POISONED(__sanitizer_unaligned_load16(x+7)); 2474 EXPECT_NOT_POISONED(__sanitizer_unaligned_load16(x+8)); 2475 EXPECT_NOT_POISONED(__sanitizer_unaligned_load16(x+9)); 2476 EXPECT_NOT_POISONED(__sanitizer_unaligned_load16(x+22)); 2477 EXPECT_POISONED(__sanitizer_unaligned_load16(x+23)); 2478 EXPECT_POISONED(__sanitizer_unaligned_load16(x+24)); 2479 2480 EXPECT_POISONED(__sanitizer_unaligned_load32(x+4)); 2481 EXPECT_POISONED(__sanitizer_unaligned_load32(x+7)); 2482 EXPECT_NOT_POISONED(__sanitizer_unaligned_load32(x+8)); 2483 EXPECT_NOT_POISONED(__sanitizer_unaligned_load32(x+9)); 2484 EXPECT_NOT_POISONED(__sanitizer_unaligned_load32(x+20)); 2485 EXPECT_POISONED(__sanitizer_unaligned_load32(x+21)); 2486 EXPECT_POISONED(__sanitizer_unaligned_load32(x+24)); 2487 2488 EXPECT_POISONED(__sanitizer_unaligned_load64(x)); 2489 EXPECT_POISONED(__sanitizer_unaligned_load64(x+1)); 2490 EXPECT_POISONED(__sanitizer_unaligned_load64(x+7)); 2491 EXPECT_NOT_POISONED(__sanitizer_unaligned_load64(x+8)); 2492 EXPECT_NOT_POISONED(__sanitizer_unaligned_load64(x+9)); 2493 EXPECT_NOT_POISONED(__sanitizer_unaligned_load64(x+16)); 2494 EXPECT_POISONED(__sanitizer_unaligned_load64(x+17)); 2495 EXPECT_POISONED(__sanitizer_unaligned_load64(x+21)); 2496 EXPECT_POISONED(__sanitizer_unaligned_load64(x+24)); 2497} 2498 2499TEST(MemorySanitizer, UnalignedStore16) { 2500 char x[5]; 2501 U2 y = 0; 2502 __msan_poison(&y, 1); 2503 __sanitizer_unaligned_store16(x + 1, y); 2504 EXPECT_POISONED(x[0]); 2505 EXPECT_POISONED(x[1]); 2506 EXPECT_NOT_POISONED(x[2]); 2507 EXPECT_POISONED(x[3]); 2508 EXPECT_POISONED(x[4]); 2509} 2510 2511TEST(MemorySanitizer, UnalignedStore32) { 2512 char x[8]; 2513 U4 y4 = 0; 2514 __msan_poison(&y4, 2); 2515 __sanitizer_unaligned_store32(x+3, y4); 2516 EXPECT_POISONED(x[0]); 2517 EXPECT_POISONED(x[1]); 2518 EXPECT_POISONED(x[2]); 2519 EXPECT_POISONED(x[3]); 2520 EXPECT_POISONED(x[4]); 2521 EXPECT_NOT_POISONED(x[5]); 2522 EXPECT_NOT_POISONED(x[6]); 2523 EXPECT_POISONED(x[7]); 2524} 2525 2526TEST(MemorySanitizer, UnalignedStore64) { 2527 char x[16]; 2528 U8 y = 0; 2529 __msan_poison(&y, 3); 2530 __msan_poison(((char *)&y) + sizeof(y) - 2, 1); 2531 __sanitizer_unaligned_store64(x+3, y); 2532 EXPECT_POISONED(x[0]); 2533 EXPECT_POISONED(x[1]); 2534 EXPECT_POISONED(x[2]); 2535 EXPECT_POISONED(x[3]); 2536 EXPECT_POISONED(x[4]); 2537 EXPECT_POISONED(x[5]); 2538 EXPECT_NOT_POISONED(x[6]); 2539 EXPECT_NOT_POISONED(x[7]); 2540 EXPECT_NOT_POISONED(x[8]); 2541 EXPECT_POISONED(x[9]); 2542 EXPECT_NOT_POISONED(x[10]); 2543 EXPECT_POISONED(x[11]); 2544} 2545 2546TEST(MemorySanitizerDr, StoreInDSOTest) { 2547 if (!__msan_has_dynamic_component()) return; 2548 char* s = new char[10]; 2549 dso_memfill(s, 9); 2550 EXPECT_NOT_POISONED(s[5]); 2551 EXPECT_POISONED(s[9]); 2552} 2553 2554int return_poisoned_int() { 2555 return ReturnPoisoned<U8>(); 2556} 2557 2558TEST(MemorySanitizerDr, ReturnFromDSOTest) { 2559 if (!__msan_has_dynamic_component()) return; 2560 EXPECT_NOT_POISONED(dso_callfn(return_poisoned_int)); 2561} 2562 2563NOINLINE int TrashParamTLS(long long x, long long y, long long z) { //NOLINT 2564 EXPECT_POISONED(x); 2565 EXPECT_POISONED(y); 2566 EXPECT_POISONED(z); 2567 return 0; 2568} 2569 2570static int CheckParamTLS(long long x, long long y, long long z) { //NOLINT 2571 EXPECT_NOT_POISONED(x); 2572 EXPECT_NOT_POISONED(y); 2573 EXPECT_NOT_POISONED(z); 2574 return 0; 2575} 2576 2577TEST(MemorySanitizerDr, CallFromDSOTest) { 2578 if (!__msan_has_dynamic_component()) return; 2579 S8* x = GetPoisoned<S8>(); 2580 S8* y = GetPoisoned<S8>(); 2581 S8* z = GetPoisoned<S8>(); 2582 EXPECT_NOT_POISONED(TrashParamTLS(*x, *y, *z)); 2583 EXPECT_NOT_POISONED(dso_callfn1(CheckParamTLS)); 2584} 2585 2586static void StackStoreInDSOFn(int* x, int* y) { 2587 EXPECT_NOT_POISONED(*x); 2588 EXPECT_NOT_POISONED(*y); 2589} 2590 2591TEST(MemorySanitizerDr, StackStoreInDSOTest) { 2592 if (!__msan_has_dynamic_component()) return; 2593 dso_stack_store(StackStoreInDSOFn, 1); 2594} 2595 2596TEST(MemorySanitizerOrigins, SetGet) { 2597 EXPECT_EQ(TrackingOrigins(), __msan_get_track_origins()); 2598 if (!TrackingOrigins()) return; 2599 int x; 2600 __msan_set_origin(&x, sizeof(x), 1234); 2601 EXPECT_EQ(1234, __msan_get_origin(&x)); 2602 __msan_set_origin(&x, sizeof(x), 5678); 2603 EXPECT_EQ(5678, __msan_get_origin(&x)); 2604 __msan_set_origin(&x, sizeof(x), 0); 2605 EXPECT_EQ(0, __msan_get_origin(&x)); 2606} 2607 2608namespace { 2609struct S { 2610 U4 dummy; 2611 U2 a; 2612 U2 b; 2613}; 2614 2615// http://code.google.com/p/memory-sanitizer/issues/detail?id=6 2616TEST(MemorySanitizerOrigins, DISABLED_InitializedStoreDoesNotChangeOrigin) { 2617 if (!TrackingOrigins()) return; 2618 2619 S s; 2620 U4 origin = rand(); // NOLINT 2621 s.a = *GetPoisonedO<U2>(0, origin); 2622 EXPECT_EQ(origin, __msan_get_origin(&s.a)); 2623 EXPECT_EQ(origin, __msan_get_origin(&s.b)); 2624 2625 s.b = 42; 2626 EXPECT_EQ(origin, __msan_get_origin(&s.a)); 2627 EXPECT_EQ(origin, __msan_get_origin(&s.b)); 2628} 2629} // namespace 2630 2631template<class T, class BinaryOp> 2632INLINE 2633void BinaryOpOriginTest(BinaryOp op) { 2634 U4 ox = rand(); //NOLINT 2635 U4 oy = rand(); //NOLINT 2636 T *x = GetPoisonedO<T>(0, ox, 0); 2637 T *y = GetPoisonedO<T>(1, oy, 0); 2638 T *z = GetPoisonedO<T>(2, 0, 0); 2639 2640 *z = op(*x, *y); 2641 U4 origin = __msan_get_origin(z); 2642 EXPECT_POISONED_O(*z, origin); 2643 EXPECT_EQ(true, origin == ox || origin == oy); 2644 2645 // y is poisoned, x is not. 2646 *x = 10101; 2647 *y = *GetPoisonedO<T>(1, oy); 2648 break_optimization(x); 2649 __msan_set_origin(z, sizeof(*z), 0); 2650 *z = op(*x, *y); 2651 EXPECT_POISONED_O(*z, oy); 2652 EXPECT_EQ(__msan_get_origin(z), oy); 2653 2654 // x is poisoned, y is not. 2655 *x = *GetPoisonedO<T>(0, ox); 2656 *y = 10101010; 2657 break_optimization(y); 2658 __msan_set_origin(z, sizeof(*z), 0); 2659 *z = op(*x, *y); 2660 EXPECT_POISONED_O(*z, ox); 2661 EXPECT_EQ(__msan_get_origin(z), ox); 2662} 2663 2664template<class T> INLINE T XOR(const T &a, const T&b) { return a ^ b; } 2665template<class T> INLINE T ADD(const T &a, const T&b) { return a + b; } 2666template<class T> INLINE T SUB(const T &a, const T&b) { return a - b; } 2667template<class T> INLINE T MUL(const T &a, const T&b) { return a * b; } 2668template<class T> INLINE T AND(const T &a, const T&b) { return a & b; } 2669template<class T> INLINE T OR (const T &a, const T&b) { return a | b; } 2670 2671TEST(MemorySanitizerOrigins, BinaryOp) { 2672 if (!TrackingOrigins()) return; 2673 BinaryOpOriginTest<S8>(XOR<S8>); 2674 BinaryOpOriginTest<U8>(ADD<U8>); 2675 BinaryOpOriginTest<S4>(SUB<S4>); 2676 BinaryOpOriginTest<S4>(MUL<S4>); 2677 BinaryOpOriginTest<U4>(OR<U4>); 2678 BinaryOpOriginTest<U4>(AND<U4>); 2679 BinaryOpOriginTest<double>(ADD<U4>); 2680 BinaryOpOriginTest<float>(ADD<S4>); 2681 BinaryOpOriginTest<double>(ADD<double>); 2682 BinaryOpOriginTest<float>(ADD<double>); 2683} 2684 2685TEST(MemorySanitizerOrigins, Unary) { 2686 if (!TrackingOrigins()) return; 2687 EXPECT_POISONED_O(*GetPoisonedO<S8>(0, __LINE__), __LINE__); 2688 EXPECT_POISONED_O(*GetPoisonedO<S8>(0, __LINE__), __LINE__); 2689 EXPECT_POISONED_O(*GetPoisonedO<S8>(0, __LINE__), __LINE__); 2690 EXPECT_POISONED_O(*GetPoisonedO<S8>(0, __LINE__), __LINE__); 2691 2692 EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__); 2693 EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__); 2694 EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__); 2695 EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__); 2696 2697 EXPECT_POISONED_O(*GetPoisonedO<U4>(0, __LINE__), __LINE__); 2698 EXPECT_POISONED_O(*GetPoisonedO<U4>(0, __LINE__), __LINE__); 2699 EXPECT_POISONED_O(*GetPoisonedO<U4>(0, __LINE__), __LINE__); 2700 EXPECT_POISONED_O(*GetPoisonedO<U4>(0, __LINE__), __LINE__); 2701 2702 EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__); 2703 EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__); 2704 EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__); 2705 EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__); 2706 2707 EXPECT_POISONED_O((void*)*GetPoisonedO<S8>(0, __LINE__), __LINE__); 2708 EXPECT_POISONED_O((U8)*GetPoisonedO<void*>(0, __LINE__), __LINE__); 2709} 2710 2711TEST(MemorySanitizerOrigins, EQ) { 2712 if (!TrackingOrigins()) return; 2713 EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__) <= 11, __LINE__); 2714 EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__) == 11, __LINE__); 2715 EXPECT_POISONED_O(*GetPoisonedO<float>(0, __LINE__) == 1.1, __LINE__); 2716} 2717 2718TEST(MemorySanitizerOrigins, DIV) { 2719 if (!TrackingOrigins()) return; 2720 EXPECT_POISONED_O(*GetPoisonedO<U8>(0, __LINE__) / 100, __LINE__); 2721 unsigned o = __LINE__; 2722 EXPECT_UMR_O(volatile unsigned y = 100 / *GetPoisonedO<S4>(0, o, 1), o); 2723} 2724 2725TEST(MemorySanitizerOrigins, SHIFT) { 2726 if (!TrackingOrigins()) return; 2727 EXPECT_POISONED_O(*GetPoisonedO<U8>(0, __LINE__) >> 10, __LINE__); 2728 EXPECT_POISONED_O(*GetPoisonedO<S8>(0, __LINE__) >> 10, __LINE__); 2729 EXPECT_POISONED_O(*GetPoisonedO<S8>(0, __LINE__) << 10, __LINE__); 2730 EXPECT_POISONED_O(10U << *GetPoisonedO<U8>(0, __LINE__), __LINE__); 2731 EXPECT_POISONED_O(-10 >> *GetPoisonedO<S8>(0, __LINE__), __LINE__); 2732 EXPECT_POISONED_O(-10 << *GetPoisonedO<S8>(0, __LINE__), __LINE__); 2733} 2734 2735template<class T, int N> 2736void MemCpyTest() { 2737 int ox = __LINE__; 2738 T *x = new T[N]; 2739 T *y = new T[N]; 2740 T *z = new T[N]; 2741 T *q = new T[N]; 2742 __msan_poison(x, N * sizeof(T)); 2743 __msan_set_origin(x, N * sizeof(T), ox); 2744 __msan_set_origin(y, N * sizeof(T), 777777); 2745 __msan_set_origin(z, N * sizeof(T), 888888); 2746 EXPECT_NOT_POISONED(x); 2747 memcpy(y, x, N * sizeof(T)); 2748 EXPECT_POISONED_O(y[0], ox); 2749 EXPECT_POISONED_O(y[N/2], ox); 2750 EXPECT_POISONED_O(y[N-1], ox); 2751 EXPECT_NOT_POISONED(x); 2752 void *res = mempcpy(q, x, N * sizeof(T)); 2753 ASSERT_EQ(q + N, res); 2754 EXPECT_POISONED_O(q[0], ox); 2755 EXPECT_POISONED_O(q[N/2], ox); 2756 EXPECT_POISONED_O(q[N-1], ox); 2757 EXPECT_NOT_POISONED(x); 2758 memmove(z, x, N * sizeof(T)); 2759 EXPECT_POISONED_O(z[0], ox); 2760 EXPECT_POISONED_O(z[N/2], ox); 2761 EXPECT_POISONED_O(z[N-1], ox); 2762} 2763 2764TEST(MemorySanitizerOrigins, LargeMemCpy) { 2765 if (!TrackingOrigins()) return; 2766 MemCpyTest<U1, 10000>(); 2767 MemCpyTest<U8, 10000>(); 2768} 2769 2770TEST(MemorySanitizerOrigins, SmallMemCpy) { 2771 if (!TrackingOrigins()) return; 2772 MemCpyTest<U8, 1>(); 2773 MemCpyTest<U8, 2>(); 2774 MemCpyTest<U8, 3>(); 2775} 2776 2777TEST(MemorySanitizerOrigins, Select) { 2778 if (!TrackingOrigins()) return; 2779 EXPECT_NOT_POISONED(g_one ? 1 : *GetPoisonedO<S4>(0, __LINE__)); 2780 EXPECT_POISONED_O(*GetPoisonedO<S4>(0, __LINE__), __LINE__); 2781 S4 x; 2782 break_optimization(&x); 2783 x = g_1 ? *GetPoisonedO<S4>(0, __LINE__) : 0; 2784 2785 EXPECT_POISONED_O(g_1 ? *GetPoisonedO<S4>(0, __LINE__) : 1, __LINE__); 2786 EXPECT_POISONED_O(g_0 ? 1 : *GetPoisonedO<S4>(0, __LINE__), __LINE__); 2787} 2788 2789extern "C" 2790NOINLINE char AllocaTO() { 2791 int ar[100]; 2792 break_optimization(ar); 2793 return ar[10]; 2794 // fprintf(stderr, "Descr: %s\n", 2795 // __msan_get_origin_descr_if_stack(__msan_get_origin_tls())); 2796} 2797 2798TEST(MemorySanitizerOrigins, Alloca) { 2799 if (!TrackingOrigins()) return; 2800 EXPECT_POISONED_S(AllocaTO(), "ar@AllocaTO"); 2801 EXPECT_POISONED_S(AllocaTO(), "ar@AllocaTO"); 2802 EXPECT_POISONED_S(AllocaTO(), "ar@AllocaTO"); 2803 EXPECT_POISONED_S(AllocaTO(), "ar@AllocaTO"); 2804} 2805 2806// FIXME: replace with a lit-like test. 2807TEST(MemorySanitizerOrigins, DISABLED_AllocaDeath) { 2808 if (!TrackingOrigins()) return; 2809 EXPECT_DEATH(AllocaTO(), "ORIGIN: stack allocation: ar@AllocaTO"); 2810} 2811 2812NOINLINE int RetvalOriginTest(U4 origin) { 2813 int *a = new int; 2814 break_optimization(a); 2815 __msan_set_origin(a, sizeof(*a), origin); 2816 int res = *a; 2817 delete a; 2818 return res; 2819} 2820 2821TEST(MemorySanitizerOrigins, Retval) { 2822 if (!TrackingOrigins()) return; 2823 EXPECT_POISONED_O(RetvalOriginTest(__LINE__), __LINE__); 2824} 2825 2826NOINLINE void ParamOriginTest(int param, U4 origin) { 2827 EXPECT_POISONED_O(param, origin); 2828} 2829 2830TEST(MemorySanitizerOrigins, Param) { 2831 if (!TrackingOrigins()) return; 2832 int *a = new int; 2833 U4 origin = __LINE__; 2834 break_optimization(a); 2835 __msan_set_origin(a, sizeof(*a), origin); 2836 ParamOriginTest(*a, origin); 2837 delete a; 2838} 2839 2840TEST(MemorySanitizerOrigins, Invoke) { 2841 if (!TrackingOrigins()) return; 2842 StructWithDtor s; // Will cause the calls to become invokes. 2843 EXPECT_POISONED_O(RetvalOriginTest(__LINE__), __LINE__); 2844} 2845 2846TEST(MemorySanitizerOrigins, strlen) { 2847 S8 alignment; 2848 break_optimization(&alignment); 2849 char x[4] = {'a', 'b', 0, 0}; 2850 __msan_poison(&x[2], 1); 2851 U4 origin = __LINE__; 2852 __msan_set_origin(x, sizeof(x), origin); 2853 EXPECT_UMR_O(volatile unsigned y = strlen(x), origin); 2854} 2855 2856TEST(MemorySanitizerOrigins, wcslen) { 2857 wchar_t w[3] = {'a', 'b', 0}; 2858 U4 origin = __LINE__; 2859 __msan_set_origin(w, sizeof(w), origin); 2860 __msan_poison(&w[2], sizeof(wchar_t)); 2861 EXPECT_UMR_O(volatile unsigned y = wcslen(w), origin); 2862} 2863 2864#if MSAN_HAS_M128 2865TEST(MemorySanitizerOrigins, StoreIntrinsic) { 2866 __m128 x, y; 2867 U4 origin = __LINE__; 2868 __msan_set_origin(&x, sizeof(x), origin); 2869 __msan_poison(&x, sizeof(x)); 2870 __builtin_ia32_storeups((float*)&y, x); 2871 EXPECT_POISONED_O(y, origin); 2872} 2873#endif 2874 2875NOINLINE void RecursiveMalloc(int depth) { 2876 static int count; 2877 count++; 2878 if ((count % (1024 * 1024)) == 0) 2879 printf("RecursiveMalloc: %d\n", count); 2880 int *x1 = new int; 2881 int *x2 = new int; 2882 break_optimization(x1); 2883 break_optimization(x2); 2884 if (depth > 0) { 2885 RecursiveMalloc(depth-1); 2886 RecursiveMalloc(depth-1); 2887 } 2888 delete x1; 2889 delete x2; 2890} 2891 2892TEST(MemorySanitizer, CallocOverflow) { 2893 size_t kArraySize = 4096; 2894 volatile size_t kMaxSizeT = std::numeric_limits<size_t>::max(); 2895 volatile size_t kArraySize2 = kMaxSizeT / kArraySize + 10; 2896 void *p = calloc(kArraySize, kArraySize2); // Should return 0. 2897 EXPECT_EQ(0L, Ident(p)); 2898} 2899 2900TEST(MemorySanitizerStress, DISABLED_MallocStackTrace) { 2901 RecursiveMalloc(22); 2902} 2903 2904TEST(MemorySanitizerAllocator, get_estimated_allocated_size) { 2905 size_t sizes[] = {0, 20, 5000, 1<<20}; 2906 for (size_t i = 0; i < sizeof(sizes) / sizeof(*sizes); ++i) { 2907 size_t alloc_size = __msan_get_estimated_allocated_size(sizes[i]); 2908 EXPECT_EQ(alloc_size, sizes[i]); 2909 } 2910} 2911 2912TEST(MemorySanitizerAllocator, get_allocated_size_and_ownership) { 2913 char *array = reinterpret_cast<char*>(malloc(100)); 2914 int *int_ptr = new int; 2915 2916 EXPECT_TRUE(__msan_get_ownership(array)); 2917 EXPECT_EQ(100, __msan_get_allocated_size(array)); 2918 2919 EXPECT_TRUE(__msan_get_ownership(int_ptr)); 2920 EXPECT_EQ(sizeof(*int_ptr), __msan_get_allocated_size(int_ptr)); 2921 2922 void *wild_addr = reinterpret_cast<void*>(0x1); 2923 EXPECT_FALSE(__msan_get_ownership(wild_addr)); 2924 EXPECT_EQ(0, __msan_get_allocated_size(wild_addr)); 2925 2926 EXPECT_FALSE(__msan_get_ownership(array + 50)); 2927 EXPECT_EQ(0, __msan_get_allocated_size(array + 50)); 2928 2929 // NULL is a valid argument for GetAllocatedSize but is not owned. 2930 EXPECT_FALSE(__msan_get_ownership(NULL)); 2931 EXPECT_EQ(0, __msan_get_allocated_size(NULL)); 2932 2933 free(array); 2934 EXPECT_FALSE(__msan_get_ownership(array)); 2935 EXPECT_EQ(0, __msan_get_allocated_size(array)); 2936 2937 delete int_ptr; 2938} 2939