自学教程：C++ ASSERT_NOT_IMPLEMENTED函数代码示例

voidinsert_pop_all_registers(dcontext_t *dcontext, clean_call_info_t *cci,                         instrlist_t *ilist, instr_t *instr,                         uint alignment){    ASSERT_NOT_IMPLEMENTED(false); /* FIXME i#1569 */}

voidIOV_WriteIovToBuf(struct iovec* entries,   // IN                  int numEntries,          // IN                  uint8* bufOut,           // OUT                  size_t bufSize)          // IN{   size_t count = 0;   int i;   ASSERT(entries);   ASSERT(bufOut);   for (i = 0; i < numEntries; i++) {      size_t numBytes;      ASSERT(entries[i].iov_base);      ASSERT(entries[i].iov_base != LAZY_ALLOC_MAGIC);      numBytes = MIN(bufSize - count, entries[i].iov_len);      Util_Memcpy(&bufOut[count], entries[i].iov_base, numBytes);      count += numBytes;      if (count >= bufSize) {         return;      }      ASSERT_NOT_IMPLEMENTED(count <= bufSize);   }}

intinsert_out_of_line_context_switch(dcontext_t *dcontext, instrlist_t *ilist,                                  instr_t *instr, bool save){    ASSERT_NOT_IMPLEMENTED(false); /* FIXME i#1569 */    return 0;}

voidinsert_push_immed_arch(dcontext_t *dcontext, instr_t *src_inst, byte *encode_estimate,                       ptr_int_t val, instrlist_t *ilist, instr_t *instr,                       instr_t **first, instr_t **second){    ASSERT_NOT_IMPLEMENTED(false); /* FIXME i#1569 */}

voidIOV_WriteBufToIov(const uint8* bufIn,           // IN                  size_t bufSize,               // IN                  struct iovec* entries,        // OUT                  int numEntries)               // IN{   size_t count = 0;   int i;   ASSERT(entries);   ASSERT_BUG(29009, bufIn);   for (i = 0; i < numEntries; i++) {      size_t numBytes;      ASSERT(entries[i].iov_base);      ASSERT(entries[i].iov_base != LAZY_ALLOC_MAGIC);      numBytes = MIN(bufSize - count, entries[i].iov_len);      Util_Memcpy(entries[i].iov_base, &bufIn[count], numBytes);      count += numBytes;      if (count >= bufSize) {         return;      }      ASSERT_NOT_IMPLEMENTED(count <= bufSize);   }}

boolcheck_undefined_exceptions(bool pushpop, bool write, app_loc_t *loc, app_pc addr,                           uint sz, uint *shadow, dr_mcontext_t *mc, uint *idx){    ASSERT_NOT_IMPLEMENTED(); /* FIXME i#1726: NYI */    return false;}

/* XXX i#1286: move to nudge_macos.c once we implement that */boolsend_nudge_signal(process_id_t pid, uint action_mask, client_id_t client_id,                  uint64 client_arg){    ASSERT_NOT_IMPLEMENTED(false); /* FIXME i#1286: MacOS nudges NYI */    return false;}

byte *remangle_short_rewrite(dcontext_t *dcontext,                       instr_t *instr, byte *pc, app_pc target){    ASSERT_NOT_IMPLEMENTED(false); /* FIXME i#1569 */    return NULL;}

boolcheck_undefined_reg_exceptions(void *drcontext, app_loc_t *loc, reg_id_t reg,                               dr_mcontext_t *mc, instr_t *inst){    ASSERT_NOT_IMPLEMENTED(); /* FIXME i#1726: NYI */    return false;}

DR_APIsize_tproc_fpstate_save_size(void){    ASSERT_NOT_IMPLEMENTED(false); /* FIXME i#1569 */    return 0;}

voidclean_call_opt_init(void){    /* FIXME i#1569: NYI on AArch64 */    ASSERT_NOT_IMPLEMENTED(INTERNAL_OPTION(opt_cleancall) == 0);    callee_info_init(&default_callee_info);}

uintinsert_parameter_preparation(dcontext_t *dcontext, instrlist_t *ilist, instr_t *instr,                             bool clean_call, uint num_args, opnd_t *args){    ASSERT_NOT_IMPLEMENTED(false); /* FIXME i#1569 */    return 0;}

voidRpcIn_RegisterCallback(RpcIn *in,               // IN                       const char *name,        // IN                       RpcIn_Callback cb,       // IN                       void *clientData)        // IN{   RpcInCallbackList *p;   Debug("Registering callback '%s'/n", name);   ASSERT(in);   ASSERT(name);   ASSERT(cb);   ASSERT(RpcInLookupCallback(in, name) == NULL); // not there yet   p = (RpcInCallbackList *) malloc(sizeof(RpcInCallbackList));   ASSERT_NOT_IMPLEMENTED(p);   p->length = strlen(name);   p->name = strdup(name);   p->callback = cb;   p->clientData = clientData;   p->next = in->callbacks;   in->callbacks = p;}

DR_APIapp_pcdr_app_pc_as_load_target(dr_isa_mode_t isa_mode, app_pc pc){    ASSERT_NOT_IMPLEMENTED(false); /* FIXME i#1569 */    return 0;}

DR_APIconst char *decode_opcode_name(int opcode){    ASSERT_NOT_IMPLEMENTED(false); /* FIXME i#1569 */    return NULL;}

uintinsert_push_all_registers(dcontext_t *dcontext, clean_call_info_t *cci,                          instrlist_t *ilist, instr_t *instr,                          uint alignment, opnd_t push_pc, reg_id_t scratch/*optional*/){    ASSERT_NOT_IMPLEMENTED(false); /* FIXME i#1569 */    return 0;}

boolinsert_reachable_cti(dcontext_t *dcontext, instrlist_t *ilist, instr_t *where,                     byte *encode_pc, byte *target, bool jmp, bool returns, bool precise,                     reg_id_t scratch, instr_t **inlined_tgt_instr){    ASSERT_NOT_IMPLEMENTED(false); /* FIXME i#1569 */    return false;}

boolanalyze_clean_call(dcontext_t *dcontext, clean_call_info_t *cci, instr_t *where,                   void *callee, bool save_fpstate, uint num_args, opnd_t *args){    /* FIXME i#1569: NYI on AArch64 */    ASSERT_NOT_IMPLEMENTED(INTERNAL_OPTION(opt_cleancall) == 0);    clean_call_info_init(cci, callee, save_fpstate, num_args);    return false;}

boolmodule_read_program_header(app_pc base, uint segment_num,                           OUT app_pc *segment_base /* relative pc */,                           OUT app_pc *segment_end /* relative pc */,                           OUT uint *segment_prot, OUT size_t *segment_align){    ASSERT_NOT_IMPLEMENTED(false); /* FIXME i#58: implement MachO support */    return false;}

BoolCodeSet_Validate(const char *buf,   // IN: the string                 size_t size,	    // IN: length of string                 const char *code)  // IN: encoding{#if defined(NO_ICU)   return CodeSetOld_Validate(buf, size, code);#else   UConverter *cv;   UErrorCode uerr;   // ucnv_toUChars takes 32-bit int size   ASSERT_NOT_IMPLEMENTED(size <= (size_t) MAX_INT32);   if (size == 0) {      return TRUE;   }   /*    * Fallback if necessary.    */   if (dontUseIcu) {      return CodeSetOld_Validate(buf, size, code);   }   /*    * Calling ucnv_toUChars() this way is the idiom to precompute    * the length of the output.  (See preflighting in the ICU User Guide.)    * So if the error is not U_BUFFER_OVERFLOW_ERROR, then the input    * is bad.    */   uerr = U_ZERO_ERROR;   cv = ucnv_open(code, &uerr);   ASSERT_NOT_IMPLEMENTED(uerr == U_ZERO_ERROR);   ucnv_setToUCallBack(cv, UCNV_TO_U_CALLBACK_STOP, NULL, NULL, NULL, &uerr);   ASSERT_NOT_IMPLEMENTED(uerr == U_ZERO_ERROR);   ucnv_toUChars(cv, NULL, 0, buf, size, &uerr);   ucnv_close(cv);   return uerr == U_BUFFER_OVERFLOW_ERROR;#endif}

static VThreadBaseKeyTypeVThreadBaseGetKey(void){   VThreadBaseKeyType key = Atomic_Read(&vthreadBaseGlobals.key);   if (key == VTHREADBASE_INVALID_KEY) {      VThreadBaseKeyType newKey;#if defined _WIN32      newKey = TlsAlloc();      ASSERT_NOT_IMPLEMENTED(newKey != VTHREADBASE_INVALID_KEY);#else      Bool success = pthread_key_create(&newKey,                                         &VThreadBaseSafeDeleteTLS) == 0;      if (success && newKey == 0) {         /*           * Leak TLS key 0.  System libraries have a habit of destroying          * it.  See bugs 702818 and 773420.          */         success = pthread_key_create(&newKey,                                       &VThreadBaseSafeDeleteTLS) == 0;      }      ASSERT_NOT_IMPLEMENTED(success);#endif      if (Atomic_ReadIfEqualWrite(&vthreadBaseGlobals.key,                                  VTHREADBASE_INVALID_KEY,                                  newKey) != VTHREADBASE_INVALID_KEY) {         /* Race: someone else init'd */#if defined _WIN32         TlsFree(newKey);#else         pthread_key_delete(newKey);#endif      }      key = Atomic_Read(&vthreadBaseGlobals.key);      ASSERT(key != VTHREADBASE_INVALID_KEY);   }   return key;}

/* Assumes it's passed either SEG_FS or SEG_GS. * Sets only the base: does not change the segment selector register. */booltls_set_fs_gs_segment_base(tls_type_t tls_type, uint seg,                           /* For x64 and TLS_TYPE_ARCH_PRCTL, base is used:                            * else, desc is used.                            */                           byte *base, our_modify_ldt_t *desc){    /* XXX: we may want to refactor os.c + tls.h to not use our_modify_ldt_t on MacOS */    ASSERT_NOT_IMPLEMENTED(false);    return false;}

static voidVThreadBaseSafeDeleteTLS(void *tlsData){   VThreadBaseData *data = tlsData;   if (data != NULL) {      if (vthreadBaseGlobals.freeIDFunc != NULL) {         VThreadBaseKeyType key = VThreadBaseGetKey();         Bool success;         VThreadBaseData tmpData = *data;         /*          * Cleanup routines (specifically, Log()) need to be called with          * valid TLS, so switch to a stack-based TLS slot containing just          * enough for the VThreadBase services, clean up, then clear the          * TLS slot.          */#if defined _WIN32         success = TlsSetValue(key, &tmpData);#else         success = pthread_setspecific(key, &tmpData) == 0;#endif         ASSERT_NOT_IMPLEMENTED(success);         if (vmx86_debug) {            Log("Forgetting VThreadID %d (/"%s/")./n", data->id, data->name);         }         (*vthreadBaseGlobals.freeIDFunc)(data);#if defined _WIN32         success = TlsSetValue(key, NULL);#else         success = pthread_setspecific(key, NULL) == 0;#endif         ASSERT_NOT_IMPLEMENTED(success);      }      Atomic_Dec(&vthreadBaseGlobals.numThreads);   }}

voidVThreadBase_ForgetSelf(void){   VThreadBaseKeyType key = VThreadBaseGetKey();   VThreadBaseData *data = VThreadBaseRaw();   Bool success;#if defined _WIN32   success = TlsSetValue(key, NULL);#else   success = pthread_setspecific(key, NULL) == 0;#endif   ASSERT_NOT_IMPLEMENTED(success);   VThreadBaseSafeDeleteTLS(data);}

static wchar_t *StrVaswprintf_Internal(size_t *length,         // OUT                       const wchar_t *format,  // IN                       va_list arguments,      // IN                       Bool assertOnFailure)   // IN{   size_t bufSize;   wchar_t *buf = NULL;   int retval;   bufSize = wcslen(format);   do {      /*       * Initial allocation of wcslen(format) * 2. Should this be tunable?       * XXX Yes, this could overflow and spin forever when you get near 2GB       *     allocations. I don't care. --rrdharan       */      wchar_t *newBuf;      bufSize *= 2;      newBuf = realloc(buf, bufSize*sizeof(wchar_t));      if (!newBuf) {         free(buf);         buf = NULL;         goto exit;      }      buf = newBuf;      retval = Str_Vsnwprintf(buf, bufSize, format, arguments);   } while (retval == -1);   if (length) {      *length = retval;   }   /*    * Try to trim the buffer here to save memory?    */  exit:   if (assertOnFailure) {      ASSERT_NOT_IMPLEMENTED(buf);   }   return buf;}

static intRpcDebugRun(ToolsAppCtx *ctx,            gpointer runMainLoop,            gpointer runData,            RpcDebugLibData *ldata){   CU_ErrorCode err;   CU_Suite *suite;   CU_Test *test;   ASSERT(runMainLoop != NULL);   ASSERT(ldata != NULL);   err = CU_initialize_registry();   ASSERT(err == CUE_SUCCESS);   suite = CU_add_suite(g_module_name(gPlugin), NULL, NULL);   ASSERT(suite != NULL);   test = CU_add_test(suite, g_module_name(gPlugin), RpcDebugRunLoop);   ASSERT_NOT_IMPLEMENTED(test != NULL);   gLibRunData.ctx = ctx;   gLibRunData.libData = ldata;   gLibRunData.mainLoop = runMainLoop;   gLibRunData.loopData = runData;   err = CU_basic_run_tests();   /* Clean up internal library / debug plugin state. */   ASSERT(g_atomic_int_get(&gLibRunData.refCount) >= 0);   if (gPlugin != NULL) {      g_module_close(gPlugin);      gPlugin = NULL;   }   if (CU_get_failure_list() != NULL) {      err = 1;   }   CU_cleanup_registry();   memset(&gLibRunData, 0, sizeof gLibRunData);   return (int) err;}

static voidVMToolsDllInit(void *lib){   Bool success;   WiperInitData wiperData;   Atomic_Init();#if defined(_WIN32)   wiperData.resourceModule = lib;   success = (NetUtil_LoadIpHlpApiDll() == ERROR_SUCCESS);   ASSERT(success);   success = Wiper_Init(&wiperData);   ASSERT(success);#else   (void) wiperData;   success = Wiper_Init(NULL);   ASSERT_NOT_IMPLEMENTED(success);#endif}

uid_tId_BeginSuperUser(void){   uid_t uid = Id_GetEUid();   ASSERT_NOT_IMPLEMENTED(uid != (uid_t) -1);   if (uid == 0) {      uid = (uid_t) -1; // already root; nothing to do   } else {#if defined(__APPLE__)      syscall(SYS_settid, KAUTH_UID_NONE, KAUTH_GID_NONE /* Ignored. */);#else      Id_SetRESUid((uid_t) -1, (uid_t) 0, (uid_t) -1); // effectively root#endif   }   return uid;}

voidTimeUtil_PopulateWithCurrent(Bool local,       // IN                             TimeUtil_Date *d) // OUT{#ifdef _WIN32   SYSTEMTIME currentTime;   ASSERT(d);   if (local) {      GetLocalTime(&currentTime);   } else {      GetSystemTime(&currentTime);   }   d->year   = currentTime.wYear;   d->month  = currentTime.wMonth;   d->day    = currentTime.wDay;   d->hour   = currentTime.wHour;   d->minute = currentTime.wMinute;   d->second = currentTime.wSecond;#else   struct tm *currentTime;   struct tm tmbuf;   time_t utcTime;   ASSERT(d);   utcTime = time(NULL);   if (local) {      currentTime = localtime_r(&utcTime, &tmbuf);   } else {      currentTime = gmtime_r(&utcTime, &tmbuf);   }   ASSERT_NOT_IMPLEMENTED(currentTime);   d->year   = 1900 + currentTime->tm_year;   d->month  = currentTime->tm_mon + 1;   d->day    = currentTime->tm_mday;   d->hour   = currentTime->tm_hour;   d->minute = currentTime->tm_min;   d->second = currentTime->tm_sec;#endif // _WIN32}

/* Assumes it's passed either SEG_FS or SEG_GS. * Returns POINTER_MAX on failure. */byte *tls_get_fs_gs_segment_base(uint seg){    uint selector;    uint index;    ldt_t ldt;    byte *base;    int res;    if (seg != SEG_FS && seg != SEG_GS)        return (byte *) POINTER_MAX;    selector = read_thread_register(seg);    index = SELECTOR_INDEX(selector);    LOG(THREAD_GET, LOG_THREADS, 4, "%s selector %x index %d ldt %d/n",        __FUNCTION__, selector, index, TEST(SELECTOR_IS_LDT, selector));    if (!TEST(SELECTOR_IS_LDT, selector) && selector != 0) {        ASSERT_NOT_IMPLEMENTED(false);        return (byte *) POINTER_MAX;    }    /* The man page is confusing, but experimentation shows it takes in the index,     * not a selector value.     */    res = dynamorio_mach_dep_syscall(SYS_i386_get_ldt, 3, index, &ldt, 1);    if (res < 0) {        LOG(THREAD_GET, LOG_THREADS, 4, "%s failed with code %d/n", __FUNCTION__, res);        ASSERT_NOT_REACHED();        return (byte *) POINTER_MAX;    }    base = (byte *)        (((ptr_uint_t)ldt.data.base24 << 24) |         ((ptr_uint_t)ldt.data.base16 << 16) |         (ptr_uint_t)ldt.data.base00);    LOG(THREAD_GET, LOG_THREADS, 4, "%s => base "PFX"/n", __FUNCTION__, base);    return base;}