gl_linkedhash_list.c:gl_linked_nx_create_empty: 45| 2|{ 46| 2| struct gl_list_impl *list = 47| 2| (struct gl_list_impl *) malloc (sizeof (struct gl_list_impl)); 48| | 49| 2| if (list == NULL) ------------------ | Branch (49:7): [True: 0, False: 2] ------------------ 50| 0| return NULL; 51| | 52| 2| list->base.vtable = implementation; 53| 2| list->base.equals_fn = equals_fn; 54| 2| list->base.hashcode_fn = hashcode_fn; 55| 2| list->base.dispose_fn = dispose_fn; 56| 2| list->base.allow_duplicates = allow_duplicates; 57| 2|#if WITH_HASHTABLE 58| 2| list->table_size = 11; 59| 2| list->table = 60| 2| (gl_hash_entry_t *) calloc (list->table_size, sizeof (gl_hash_entry_t)); 61| 2| if (list->table == NULL) ------------------ | Branch (61:7): [True: 0, False: 2] ------------------ 62| 0| goto fail; 63| 2|#endif 64| 2| list->root.next = &list->root; 65| 2| list->root.prev = &list->root; 66| 2| list->count = 0; 67| | 68| 2| return list; 69| | 70| 0|#if WITH_HASHTABLE 71| 0| fail: 72| 0| free (list); 73| 0| return NULL; 74| 2|#endif 75| 2|} gl_list_nx_create_empty: 607| 2|{ 608| 2| return implementation->nx_create_empty (implementation, equals_fn, 609| 2| hashcode_fn, dispose_fn, 610| 2| allow_duplicates); 611| 2|} _gnutls_register_accel_crypto: 33| 2|{ 34| 2|#if defined(ASM_X86) 35| 2| register_x86_crypto(); 36| 2|#endif 37| | 38| |#if defined(ASM_AARCH64) 39| | register_aarch64_crypto(); 40| |#endif 41| | 42| 2| return; 43| 2|} _gnutls_afalg_init: 864| 2|{ 865| 2| return 0; 866| 2|} _gnutls_cryptodev_init: 505| 2|{ 506| 2| return 0; 507| 2|} register_x86_crypto: 1235| 2|{ 1236| 2| unsigned capabilities = 0; 1237| 2| char *p; 1238| 2| p = secure_getenv("GNUTLS_CPUID_OVERRIDE"); 1239| 2| if (p) { ------------------ | Branch (1239:6): [True: 0, False: 2] ------------------ 1240| 0| capabilities = strtol(p, NULL, 0); 1241| 0| } 1242| | 1243| 2| register_x86_intel_crypto(capabilities); 1244| 2|#ifdef ENABLE_PADLOCK 1245| 2| register_x86_padlock_crypto(capabilities); 1246| 2|#endif 1247| 2|} x86-common.c:register_x86_intel_crypto: 900| 2|{ 901| 2| int ret; 902| 2| enum x86_cpu_vendor vendor; 903| | 904| 2| memset(GNUTLS_x86_cpuid_s, 0, sizeof(GNUTLS_x86_cpuid_s)); 905| | 906| 2| vendor = check_x86_cpu_vendor(); 907| 2| if (vendor == X86_CPU_VENDOR_OTHER) { ------------------ | Branch (907:6): [True: 0, False: 2] ------------------ 908| 0| return; 909| 0| } 910| | 911| 2| if (capabilities == 0) { ------------------ | Branch (911:6): [True: 2, False: 0] ------------------ 912| 2| if (!read_cpuid_vals(GNUTLS_x86_cpuid_s)) ------------------ | Branch (912:7): [True: 0, False: 2] ------------------ 913| 0| return; 914| 2| if (!check_4th_gen_intel_features(GNUTLS_x86_cpuid_s[1])) { ------------------ | Branch (914:7): [True: 0, False: 2] ------------------ 915| 0| GNUTLS_x86_cpuid_s[1] &= ~bit_AVX; 916| | 917| | /* Clear AVX2 bits as well, according to what 918| | * OpenSSL does. Should we clear 919| | * bit_AVX512DQ, bit_AVX512PF, bit_AVX512ER, 920| | * and bit_AVX512CD? */ 921| 0| GNUTLS_x86_cpuid_s[2] &= ~(bit_AVX2 | 922| 0| bit_AVX512F | 923| 0| bit_AVX512IFMA | 924| 0| bit_AVX512BW | bit_AVX512BW); 925| 0| } 926| 2| } else { 927| 0| capabilities_to_intel_cpuid(capabilities); 928| 0| } 929| | 930| | /* CRYPTOGAMS uses the (1 << 30) bit as an indicator of Intel CPUs */ 931| 2| if (vendor == X86_CPU_VENDOR_INTEL) { ------------------ | Branch (931:6): [True: 0, False: 2] ------------------ 932| 0| GNUTLS_x86_cpuid_s[0] |= 1 << 30; 933| 2| } else { 934| 2| GNUTLS_x86_cpuid_s[0] &= ~(1 << 30); 935| 2| } 936| | 937| 2| if (check_ssse3()) { ------------------ | Branch (937:6): [True: 2, False: 0] ------------------ 938| 2| _gnutls_debug_log("Intel SSSE3 was detected\n"); ------------------ | | 139| 2|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 2|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 2|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 2] | | | | | | ------------------ | | | | ------------------ | | | | 137| 2| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 939| | 940| 2| ret = 941| 2| gnutls_crypto_single_cipher_register 942| 2| (GNUTLS_CIPHER_AES_128_GCM, 90, 943| 2| &_gnutls_aes_gcm_x86_ssse3, 0); 944| 2| if (ret < 0) { ------------------ | Branch (944:7): [True: 0, False: 2] ------------------ 945| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 946| 0| } 947| | 948| 2| ret = 949| 2| gnutls_crypto_single_cipher_register 950| 2| (GNUTLS_CIPHER_AES_192_GCM, 90, 951| 2| &_gnutls_aes_gcm_x86_ssse3, 0); 952| 2| if (ret < 0) { ------------------ | Branch (952:7): [True: 0, False: 2] ------------------ 953| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 954| 0| } 955| | 956| 2| ret = 957| 2| gnutls_crypto_single_cipher_register 958| 2| (GNUTLS_CIPHER_AES_256_GCM, 90, 959| 2| &_gnutls_aes_gcm_x86_ssse3, 0); 960| 2| if (ret < 0) { ------------------ | Branch (960:7): [True: 0, False: 2] ------------------ 961| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 962| 0| } 963| | 964| 2| ret = 965| 2| gnutls_crypto_single_cipher_register 966| 2| (GNUTLS_CIPHER_AES_128_CBC, 90, &_gnutls_aes_ssse3, 0); 967| 2| if (ret < 0) { ------------------ | Branch (967:7): [True: 0, False: 2] ------------------ 968| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 969| 0| } 970| | 971| 2| ret = 972| 2| gnutls_crypto_single_cipher_register 973| 2| (GNUTLS_CIPHER_AES_192_CBC, 90, &_gnutls_aes_ssse3, 0); 974| 2| if (ret < 0) { ------------------ | Branch (974:7): [True: 0, False: 2] ------------------ 975| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 976| 0| } 977| | 978| 2| ret = 979| 2| gnutls_crypto_single_cipher_register 980| 2| (GNUTLS_CIPHER_AES_256_CBC, 90, &_gnutls_aes_ssse3, 0); 981| 2| if (ret < 0) { ------------------ | Branch (981:7): [True: 0, False: 2] ------------------ 982| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 983| 0| } 984| 2| } 985| | 986| 2| if (check_sha() || check_ssse3()) { ------------------ | Branch (986:6): [True: 2, False: 0] | Branch (986:21): [True: 0, False: 0] ------------------ 987| 2| if (check_sha()) ------------------ | Branch (987:7): [True: 2, False: 0] ------------------ 988| 2| _gnutls_debug_log("Intel SHA was detected\n"); ------------------ | | 139| 2|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 2|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 2|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 2] | | | | | | ------------------ | | | | ------------------ | | | | 137| 2| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 989| | 990| 2| ret = 991| 2| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA1, 992| 2| 80, 993| 2| &_gnutls_sha_x86_ssse3, 994| 2| 0); 995| 2| if (ret < 0) { ------------------ | Branch (995:7): [True: 0, False: 2] ------------------ 996| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 997| 0| } 998| | 999| 2| ret = 1000| 2| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA224, 1001| 2| 80, 1002| 2| &_gnutls_sha_x86_ssse3, 1003| 2| 0); 1004| 2| if (ret < 0) { ------------------ | Branch (1004:7): [True: 0, False: 2] ------------------ 1005| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1006| 0| } 1007| | 1008| 2| ret = 1009| 2| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA256, 1010| 2| 80, 1011| 2| &_gnutls_sha_x86_ssse3, 1012| 2| 0); 1013| 2| if (ret < 0) { ------------------ | Branch (1013:7): [True: 0, False: 2] ------------------ 1014| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1015| 0| } 1016| | 1017| 2| ret = 1018| 2| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA1, 1019| 2| 80, 1020| 2| &_gnutls_hmac_sha_x86_ssse3, 1021| 2| 0); 1022| 2| if (ret < 0) ------------------ | Branch (1022:7): [True: 0, False: 2] ------------------ 1023| 2| gnutls_assert(); ------------------ | | 33| 2|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1024| | 1025| 2| ret = 1026| 2| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA224, 1027| 2| 80, 1028| 2| &_gnutls_hmac_sha_x86_ssse3, 1029| 2| 0); 1030| 2| if (ret < 0) ------------------ | Branch (1030:7): [True: 0, False: 2] ------------------ 1031| 2| gnutls_assert(); ------------------ | | 33| 2|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1032| | 1033| 2| ret = 1034| 2| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA256, 1035| 2| 80, 1036| 2| &_gnutls_hmac_sha_x86_ssse3, 1037| 2| 0); 1038| 2| if (ret < 0) ------------------ | Branch (1038:7): [True: 0, False: 2] ------------------ 1039| 2| gnutls_assert(); ------------------ | | 33| 2|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1040| | 1041| 2| ret = 1042| 2| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA384, 1043| 2| 80, 1044| 2| &_gnutls_sha_x86_ssse3, 1045| 2| 0); 1046| 2| if (ret < 0) ------------------ | Branch (1046:7): [True: 0, False: 2] ------------------ 1047| 2| gnutls_assert(); ------------------ | | 33| 2|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1048| | 1049| 2| ret = 1050| 2| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA512, 1051| 2| 80, 1052| 2| &_gnutls_sha_x86_ssse3, 1053| 2| 0); 1054| 2| if (ret < 0) ------------------ | Branch (1054:7): [True: 0, False: 2] ------------------ 1055| 2| gnutls_assert(); ------------------ | | 33| 2|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1056| 2| ret = 1057| 2| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA384, 1058| 2| 80, 1059| 2| &_gnutls_hmac_sha_x86_ssse3, 1060| 2| 0); 1061| 2| if (ret < 0) ------------------ | Branch (1061:7): [True: 0, False: 2] ------------------ 1062| 2| gnutls_assert(); ------------------ | | 33| 2|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1063| | 1064| 2| ret = 1065| 2| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA512, 1066| 2| 80, 1067| 2| &_gnutls_hmac_sha_x86_ssse3, 1068| 2| 0); 1069| 2| if (ret < 0) ------------------ | Branch (1069:7): [True: 0, False: 2] ------------------ 1070| 2| gnutls_assert(); ------------------ | | 33| 2|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1071| 2| } 1072| | 1073| 2| if (check_optimized_aes()) { ------------------ | Branch (1073:6): [True: 2, False: 0] ------------------ 1074| 2| _gnutls_debug_log("Intel AES accelerator was detected\n"); ------------------ | | 139| 2|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 2|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 2|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 2] | | | | | | ------------------ | | | | ------------------ | | | | 137| 2| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1075| 2| ret = 1076| 2| gnutls_crypto_single_cipher_register 1077| 2| (GNUTLS_CIPHER_AES_128_CBC, 80, &_gnutls_aesni_x86, 0); 1078| 2| if (ret < 0) { ------------------ | Branch (1078:7): [True: 0, False: 2] ------------------ 1079| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1080| 0| } 1081| | 1082| 2| ret = 1083| 2| gnutls_crypto_single_cipher_register 1084| 2| (GNUTLS_CIPHER_AES_192_CBC, 80, &_gnutls_aesni_x86, 0); 1085| 2| if (ret < 0) { ------------------ | Branch (1085:7): [True: 0, False: 2] ------------------ 1086| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1087| 0| } 1088| | 1089| 2| ret = 1090| 2| gnutls_crypto_single_cipher_register 1091| 2| (GNUTLS_CIPHER_AES_256_CBC, 80, &_gnutls_aesni_x86, 0); 1092| 2| if (ret < 0) { ------------------ | Branch (1092:7): [True: 0, False: 2] ------------------ 1093| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1094| 0| } 1095| | 1096| 2| ret = 1097| 2| gnutls_crypto_single_cipher_register 1098| 2| (GNUTLS_CIPHER_AES_128_CCM, 80, 1099| 2| &_gnutls_aes_ccm_x86_aesni, 0); 1100| 2| if (ret < 0) { ------------------ | Branch (1100:7): [True: 0, False: 2] ------------------ 1101| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1102| 0| } 1103| | 1104| 2| ret = 1105| 2| gnutls_crypto_single_cipher_register 1106| 2| (GNUTLS_CIPHER_AES_256_CCM, 80, 1107| 2| &_gnutls_aes_ccm_x86_aesni, 0); 1108| 2| if (ret < 0) { ------------------ | Branch (1108:7): [True: 0, False: 2] ------------------ 1109| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1110| 0| } 1111| | 1112| 2| ret = 1113| 2| gnutls_crypto_single_cipher_register 1114| 2| (GNUTLS_CIPHER_AES_128_CCM_8, 80, 1115| 2| &_gnutls_aes_ccm_x86_aesni, 0); 1116| 2| if (ret < 0) { ------------------ | Branch (1116:7): [True: 0, False: 2] ------------------ 1117| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1118| 0| } 1119| | 1120| 2| ret = 1121| 2| gnutls_crypto_single_cipher_register 1122| 2| (GNUTLS_CIPHER_AES_256_CCM_8, 80, 1123| 2| &_gnutls_aes_ccm_x86_aesni, 0); 1124| 2| if (ret < 0) { ------------------ | Branch (1124:7): [True: 0, False: 2] ------------------ 1125| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1126| 0| } 1127| | 1128| 2| ret = 1129| 2| gnutls_crypto_single_cipher_register 1130| 2| (GNUTLS_CIPHER_AES_128_XTS, 80, 1131| 2| &_gnutls_aes_xts_x86_aesni, 0); 1132| 2| if (ret < 0) { ------------------ | Branch (1132:7): [True: 0, False: 2] ------------------ 1133| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1134| 0| } 1135| | 1136| 2| ret = 1137| 2| gnutls_crypto_single_cipher_register 1138| 2| (GNUTLS_CIPHER_AES_256_XTS, 80, 1139| 2| &_gnutls_aes_xts_x86_aesni, 0); 1140| 2| if (ret < 0) { ------------------ | Branch (1140:7): [True: 0, False: 2] ------------------ 1141| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1142| 0| } 1143| | 1144| 2|#ifdef ASM_X86_64 1145| 2| if (check_pclmul()) { ------------------ | Branch (1145:7): [True: 2, False: 0] ------------------ 1146| | /* register GCM ciphers */ 1147| 2| if (check_avx_movbe()) { ------------------ | Branch (1147:8): [True: 2, False: 0] ------------------ 1148| 2| _gnutls_debug_log ------------------ | | 139| 2|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 2|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 2|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 2] | | | | | | ------------------ | | | | ------------------ | | | | 137| 2| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1149| 2| ("Intel GCM accelerator (AVX) was detected\n"); 1150| 2| ret = 1151| 2| gnutls_crypto_single_cipher_register 1152| 2| (GNUTLS_CIPHER_AES_128_GCM, 80, 1153| 2| &_gnutls_aes_gcm_pclmul_avx, 0); 1154| 2| if (ret < 0) { ------------------ | Branch (1154:9): [True: 0, False: 2] ------------------ 1155| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1156| 0| } 1157| | 1158| 2| ret = 1159| 2| gnutls_crypto_single_cipher_register 1160| 2| (GNUTLS_CIPHER_AES_192_GCM, 80, 1161| 2| &_gnutls_aes_gcm_pclmul_avx, 0); 1162| 2| if (ret < 0) { ------------------ | Branch (1162:9): [True: 0, False: 2] ------------------ 1163| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1164| 0| } 1165| | 1166| 2| ret = 1167| 2| gnutls_crypto_single_cipher_register 1168| 2| (GNUTLS_CIPHER_AES_256_GCM, 80, 1169| 2| &_gnutls_aes_gcm_pclmul_avx, 0); 1170| 2| if (ret < 0) { ------------------ | Branch (1170:9): [True: 0, False: 2] ------------------ 1171| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1172| 0| } 1173| 2| } else { 1174| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1175| 0| ("Intel GCM accelerator was detected\n"); 1176| 0| ret = 1177| 0| gnutls_crypto_single_cipher_register 1178| 0| (GNUTLS_CIPHER_AES_128_GCM, 80, 1179| 0| &_gnutls_aes_gcm_pclmul, 0); 1180| 0| if (ret < 0) { ------------------ | Branch (1180:9): [True: 0, False: 0] ------------------ 1181| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1182| 0| } 1183| | 1184| 0| ret = 1185| 0| gnutls_crypto_single_cipher_register 1186| 0| (GNUTLS_CIPHER_AES_192_GCM, 80, 1187| 0| &_gnutls_aes_gcm_pclmul, 0); 1188| 0| if (ret < 0) { ------------------ | Branch (1188:9): [True: 0, False: 0] ------------------ 1189| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1190| 0| } 1191| | 1192| 0| ret = 1193| 0| gnutls_crypto_single_cipher_register 1194| 0| (GNUTLS_CIPHER_AES_256_GCM, 80, 1195| 0| &_gnutls_aes_gcm_pclmul, 0); 1196| 0| if (ret < 0) { ------------------ | Branch (1196:9): [True: 0, False: 0] ------------------ 1197| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1198| 0| } 1199| 0| } 1200| 2| } else 1201| 0|#endif 1202| 0| { 1203| 0| ret = 1204| 0| gnutls_crypto_single_cipher_register 1205| 0| (GNUTLS_CIPHER_AES_128_GCM, 80, 1206| 0| &_gnutls_aes_gcm_x86_aesni, 0); 1207| 0| if (ret < 0) { ------------------ | Branch (1207:8): [True: 0, False: 0] ------------------ 1208| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1209| 0| } 1210| | 1211| 0| ret = 1212| 0| gnutls_crypto_single_cipher_register 1213| 0| (GNUTLS_CIPHER_AES_192_GCM, 80, 1214| 0| &_gnutls_aes_gcm_x86_aesni, 0); 1215| 0| if (ret < 0) { ------------------ | Branch (1215:8): [True: 0, False: 0] ------------------ 1216| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1217| 0| } 1218| | 1219| 0| ret = 1220| 0| gnutls_crypto_single_cipher_register 1221| 0| (GNUTLS_CIPHER_AES_256_GCM, 80, 1222| 0| &_gnutls_aes_gcm_x86_aesni, 0); 1223| 0| if (ret < 0) { ------------------ | Branch (1223:8): [True: 0, False: 0] ------------------ 1224| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1225| 0| } 1226| 0| } 1227| 2| } else { 1228| 0| _gnutls_priority_update_non_aesni(); 1229| 0| } 1230| | 1231| 2| return; 1232| 2|} x86-common.c:check_x86_cpu_vendor: 878| 2|{ 879| 2| unsigned int a, b, c, d; 880| | 881| 2| if (!__get_cpuid(0, &a, &b, &c, &d)) { ------------------ | Branch (881:6): [True: 0, False: 2] ------------------ 882| 0| return X86_CPU_VENDOR_OTHER; 883| 0| } 884| | 885| 2| if (memcmp(&b, "Genu", 4) == 0 && ------------------ | Branch (885:6): [True: 0, False: 2] ------------------ 886| 2| memcmp(&d, "ineI", 4) == 0 && memcmp(&c, "ntel", 4) == 0) { ------------------ | Branch (886:6): [True: 0, False: 0] | Branch (886:36): [True: 0, False: 0] ------------------ 887| 0| return X86_CPU_VENDOR_INTEL; 888| 0| } 889| | 890| 2| if (memcmp(&b, "Auth", 4) == 0 && ------------------ | Branch (890:6): [True: 2, False: 0] ------------------ 891| 2| memcmp(&d, "enti", 4) == 0 && memcmp(&c, "cAMD", 4) == 0) { ------------------ | Branch (891:6): [True: 2, False: 0] | Branch (891:36): [True: 2, False: 0] ------------------ 892| 2| return X86_CPU_VENDOR_AMD; 893| 2| } 894| | 895| 0| return X86_CPU_VENDOR_OTHER; 896| 2|} x86-common.c:read_cpuid_vals: 145| 2|{ 146| 2| unsigned t1, t2, t3; 147| 2| vals[0] = vals[1] = vals[2] = vals[3] = 0; 148| | 149| 2| if (!__get_cpuid(1, &t1, &t2, &vals[1], &vals[0])) ------------------ | Branch (149:6): [True: 0, False: 2] ------------------ 150| 0| return 0; 151| | /* suppress AVX512; it works conditionally on certain CPUs on the original code */ 152| 2| vals[1] &= 0xfffff7ff; 153| | 154| 2| get_cpuid_level7(&t1, &vals[2], &t2, &t3); ------------------ | | 141| 2|# define get_cpuid_level7(a,b,c,d) __get_cpuid_count(7, 0, a, b, c, d) ------------------ 155| | 156| 2| return 1; 157| 2|} x86-common.c:check_4th_gen_intel_features: 164| 2|{ 165| 2| uint32_t xcr0; 166| | 167| 2| if ((ecx & bit_OSXSAVE) != bit_OSXSAVE) ------------------ | Branch (167:6): [True: 0, False: 2] ------------------ 168| 0| return 0; 169| | 170| |#if defined(_MSC_VER) && !defined(__clang__) 171| | xcr0 = _xgetbv(0); 172| |#else 173| 2| __asm__("xgetbv": "=a"(xcr0): "c"(0):"%edx"); 174| 2|#endif 175| | /* Check if xmm and ymm state are enabled in XCR0. */ 176| 2| return (xcr0 & 6) == 6; 177| 2|} x86-common.c:check_ssse3: 243| 2|{ 244| 2| return (GNUTLS_x86_cpuid_s[1] & bit_SSSE3); 245| 2|} x86-common.c:check_sha: 248| 4|{ 249| 4| return (GNUTLS_x86_cpuid_s[2] & bit_SHA); 250| 4|} x86-common.c:check_optimized_aes: 238| 2|{ 239| 2| return (GNUTLS_x86_cpuid_s[1] & bit_AES); 240| 2|} x86-common.c:check_pclmul: 260| 2|{ 261| 2| return (GNUTLS_x86_cpuid_s[1] & bit_PCLMUL); 262| 2|} x86-common.c:check_avx_movbe: 254| 2|{ 255| 2| return (GNUTLS_x86_cpuid_s[1] & (bit_AVX | bit_MOVBE)) == 256| 2| (bit_AVX | bit_MOVBE); 257| 2|} x86-common.c:register_x86_padlock_crypto: 384| 2|{ 385| 2| int ret, phe; 386| 2| unsigned edx; 387| | 388| 2| if (check_zhaoxin() == 0) ------------------ | Branch (388:6): [True: 2, False: 0] ------------------ 389| 2| return; 390| | 391| 0| memset(GNUTLS_x86_cpuid_s, 0, sizeof(GNUTLS_x86_cpuid_s)); 392| | 393| 0| if (capabilities == 0) { ------------------ | Branch (393:6): [True: 0, False: 0] ------------------ 394| 0| if (!read_cpuid_vals(GNUTLS_x86_cpuid_s)) ------------------ | Branch (394:7): [True: 0, False: 0] ------------------ 395| 0| return; 396| 0| edx = padlock_capability(); 397| 0| } else { 398| 0| capabilities_to_intel_cpuid(capabilities); 399| 0| edx = capabilities_to_zhaoxin_edx(capabilities); 400| 0| } 401| | 402| 0| if (check_ssse3()) { ------------------ | Branch (402:6): [True: 0, False: 0] ------------------ 403| 0| _gnutls_debug_log("Zhaoxin SSSE3 was detected\n"); ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 404| | 405| 0| ret = 406| 0| gnutls_crypto_single_cipher_register 407| 0| (GNUTLS_CIPHER_AES_128_GCM, 90, 408| 0| &_gnutls_aes_gcm_x86_ssse3, 0); 409| 0| if (ret < 0) { ------------------ | Branch (409:7): [True: 0, False: 0] ------------------ 410| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 411| 0| } 412| | 413| 0| ret = 414| 0| gnutls_crypto_single_cipher_register 415| 0| (GNUTLS_CIPHER_AES_192_GCM, 90, 416| 0| &_gnutls_aes_gcm_x86_ssse3, 0); 417| 0| if (ret < 0) { ------------------ | Branch (417:7): [True: 0, False: 0] ------------------ 418| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 419| 0| } 420| | 421| 0| ret = 422| 0| gnutls_crypto_single_cipher_register 423| 0| (GNUTLS_CIPHER_AES_256_GCM, 90, 424| 0| &_gnutls_aes_gcm_x86_ssse3, 0); 425| 0| if (ret < 0) { ------------------ | Branch (425:7): [True: 0, False: 0] ------------------ 426| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 427| 0| } 428| | 429| 0| ret = 430| 0| gnutls_crypto_single_cipher_register 431| 0| (GNUTLS_CIPHER_AES_128_CBC, 90, &_gnutls_aes_ssse3, 0); 432| 0| if (ret < 0) { ------------------ | Branch (432:7): [True: 0, False: 0] ------------------ 433| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 434| 0| } 435| | 436| 0| ret = 437| 0| gnutls_crypto_single_cipher_register 438| 0| (GNUTLS_CIPHER_AES_192_CBC, 90, &_gnutls_aes_ssse3, 0); 439| 0| if (ret < 0) { ------------------ | Branch (439:7): [True: 0, False: 0] ------------------ 440| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 441| 0| } 442| | 443| 0| ret = 444| 0| gnutls_crypto_single_cipher_register 445| 0| (GNUTLS_CIPHER_AES_256_CBC, 90, &_gnutls_aes_ssse3, 0); 446| 0| if (ret < 0) { ------------------ | Branch (446:7): [True: 0, False: 0] ------------------ 447| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 448| 0| } 449| 0| } 450| | 451| 0| if (check_sha() || check_ssse3()) { ------------------ | Branch (451:6): [True: 0, False: 0] | Branch (451:21): [True: 0, False: 0] ------------------ 452| 0| if (check_sha()) ------------------ | Branch (452:7): [True: 0, False: 0] ------------------ 453| 0| _gnutls_debug_log("Zhaoxin SHA was detected\n"); ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 454| | 455| 0| ret = 456| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA1, 457| 0| 80, 458| 0| &_gnutls_sha_x86_ssse3, 459| 0| 0); 460| 0| if (ret < 0) { ------------------ | Branch (460:7): [True: 0, False: 0] ------------------ 461| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 462| 0| } 463| | 464| 0| ret = 465| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA224, 466| 0| 80, 467| 0| &_gnutls_sha_x86_ssse3, 468| 0| 0); 469| 0| if (ret < 0) { ------------------ | Branch (469:7): [True: 0, False: 0] ------------------ 470| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 471| 0| } 472| | 473| 0| ret = 474| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA256, 475| 0| 80, 476| 0| &_gnutls_sha_x86_ssse3, 477| 0| 0); 478| 0| if (ret < 0) { ------------------ | Branch (478:7): [True: 0, False: 0] ------------------ 479| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 480| 0| } 481| | 482| 0| ret = 483| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA1, 484| 0| 80, 485| 0| &_gnutls_hmac_sha_x86_ssse3, 486| 0| 0); 487| 0| if (ret < 0) ------------------ | Branch (487:7): [True: 0, False: 0] ------------------ 488| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 489| | 490| 0| ret = 491| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA224, 492| 0| 80, 493| 0| &_gnutls_hmac_sha_x86_ssse3, 494| 0| 0); 495| 0| if (ret < 0) ------------------ | Branch (495:7): [True: 0, False: 0] ------------------ 496| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 497| | 498| 0| ret = 499| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA256, 500| 0| 80, 501| 0| &_gnutls_hmac_sha_x86_ssse3, 502| 0| 0); 503| 0| if (ret < 0) ------------------ | Branch (503:7): [True: 0, False: 0] ------------------ 504| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 505| | 506| 0| ret = 507| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA384, 508| 0| 80, 509| 0| &_gnutls_sha_x86_ssse3, 510| 0| 0); 511| 0| if (ret < 0) ------------------ | Branch (511:7): [True: 0, False: 0] ------------------ 512| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 513| | 514| 0| ret = 515| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA512, 516| 0| 80, 517| 0| &_gnutls_sha_x86_ssse3, 518| 0| 0); 519| 0| if (ret < 0) ------------------ | Branch (519:7): [True: 0, False: 0] ------------------ 520| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 521| 0| ret = 522| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA384, 523| 0| 80, 524| 0| &_gnutls_hmac_sha_x86_ssse3, 525| 0| 0); 526| 0| if (ret < 0) ------------------ | Branch (526:7): [True: 0, False: 0] ------------------ 527| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 528| | 529| 0| ret = 530| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA512, 531| 0| 80, 532| 0| &_gnutls_hmac_sha_x86_ssse3, 533| 0| 0); 534| 0| if (ret < 0) ------------------ | Branch (534:7): [True: 0, False: 0] ------------------ 535| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 536| 0| } 537| | 538| 0| if (check_optimized_aes()) { ------------------ | Branch (538:6): [True: 0, False: 0] ------------------ 539| 0| _gnutls_debug_log("Zhaoxin AES accelerator was detected\n"); ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 540| 0| ret = 541| 0| gnutls_crypto_single_cipher_register 542| 0| (GNUTLS_CIPHER_AES_128_CBC, 80, &_gnutls_aesni_x86, 0); 543| 0| if (ret < 0) { ------------------ | Branch (543:7): [True: 0, False: 0] ------------------ 544| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 545| 0| } 546| | 547| 0| ret = 548| 0| gnutls_crypto_single_cipher_register 549| 0| (GNUTLS_CIPHER_AES_192_CBC, 80, &_gnutls_aesni_x86, 0); 550| 0| if (ret < 0) { ------------------ | Branch (550:7): [True: 0, False: 0] ------------------ 551| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 552| 0| } 553| | 554| 0| ret = 555| 0| gnutls_crypto_single_cipher_register 556| 0| (GNUTLS_CIPHER_AES_256_CBC, 80, &_gnutls_aesni_x86, 0); 557| 0| if (ret < 0) { ------------------ | Branch (557:7): [True: 0, False: 0] ------------------ 558| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 559| 0| } 560| | 561| 0| ret = 562| 0| gnutls_crypto_single_cipher_register 563| 0| (GNUTLS_CIPHER_AES_128_CCM, 80, 564| 0| &_gnutls_aes_ccm_x86_aesni, 0); 565| 0| if (ret < 0) { ------------------ | Branch (565:7): [True: 0, False: 0] ------------------ 566| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 567| 0| } 568| | 569| 0| ret = 570| 0| gnutls_crypto_single_cipher_register 571| 0| (GNUTLS_CIPHER_AES_256_CCM, 80, 572| 0| &_gnutls_aes_ccm_x86_aesni, 0); 573| 0| if (ret < 0) { ------------------ | Branch (573:7): [True: 0, False: 0] ------------------ 574| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 575| 0| } 576| | 577| 0| ret = 578| 0| gnutls_crypto_single_cipher_register 579| 0| (GNUTLS_CIPHER_AES_128_CCM_8, 80, 580| 0| &_gnutls_aes_ccm_x86_aesni, 0); 581| 0| if (ret < 0) { ------------------ | Branch (581:7): [True: 0, False: 0] ------------------ 582| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 583| 0| } 584| | 585| 0| ret = 586| 0| gnutls_crypto_single_cipher_register 587| 0| (GNUTLS_CIPHER_AES_256_CCM_8, 80, 588| 0| &_gnutls_aes_ccm_x86_aesni, 0); 589| 0| if (ret < 0) { ------------------ | Branch (589:7): [True: 0, False: 0] ------------------ 590| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 591| 0| } 592| | 593| 0| ret = 594| 0| gnutls_crypto_single_cipher_register 595| 0| (GNUTLS_CIPHER_AES_128_XTS, 80, 596| 0| &_gnutls_aes_xts_x86_aesni, 0); 597| 0| if (ret < 0) { ------------------ | Branch (597:7): [True: 0, False: 0] ------------------ 598| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 599| 0| } 600| | 601| 0| ret = 602| 0| gnutls_crypto_single_cipher_register 603| 0| (GNUTLS_CIPHER_AES_256_XTS, 80, 604| 0| &_gnutls_aes_xts_x86_aesni, 0); 605| 0| if (ret < 0) { ------------------ | Branch (605:7): [True: 0, False: 0] ------------------ 606| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 607| 0| } 608| | 609| 0|# ifdef ASM_X86_64 610| 0| if (check_pclmul()) { ------------------ | Branch (610:7): [True: 0, False: 0] ------------------ 611| | /* register GCM ciphers */ 612| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 613| 0| ("Zhaoxin GCM accelerator was detected\n"); 614| 0| if (check_avx_movbe() && check_fast_pclmul()) { ------------------ | Branch (614:8): [True: 0, False: 0] | Branch (614:29): [True: 0, False: 0] ------------------ 615| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 616| 0| ("Zhaoxin GCM accelerator (AVX) was detected\n"); 617| 0| ret = 618| 0| gnutls_crypto_single_cipher_register 619| 0| (GNUTLS_CIPHER_AES_128_GCM, 80, 620| 0| &_gnutls_aes_gcm_pclmul_avx, 0); 621| 0| if (ret < 0) { ------------------ | Branch (621:9): [True: 0, False: 0] ------------------ 622| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 623| 0| } 624| | 625| 0| ret = 626| 0| gnutls_crypto_single_cipher_register 627| 0| (GNUTLS_CIPHER_AES_192_GCM, 80, 628| 0| &_gnutls_aes_gcm_pclmul_avx, 0); 629| 0| if (ret < 0) { ------------------ | Branch (629:9): [True: 0, False: 0] ------------------ 630| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 631| 0| } 632| | 633| 0| ret = 634| 0| gnutls_crypto_single_cipher_register 635| 0| (GNUTLS_CIPHER_AES_256_GCM, 80, 636| 0| &_gnutls_aes_gcm_pclmul_avx, 0); 637| 0| if (ret < 0) { ------------------ | Branch (637:9): [True: 0, False: 0] ------------------ 638| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 639| 0| } 640| 0| } else { 641| 0| ret = 642| 0| gnutls_crypto_single_cipher_register 643| 0| (GNUTLS_CIPHER_AES_128_GCM, 80, 644| 0| &_gnutls_aes_gcm_pclmul, 0); 645| 0| if (ret < 0) { ------------------ | Branch (645:9): [True: 0, False: 0] ------------------ 646| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 647| 0| } 648| | 649| 0| ret = 650| 0| gnutls_crypto_single_cipher_register 651| 0| (GNUTLS_CIPHER_AES_192_GCM, 80, 652| 0| &_gnutls_aes_gcm_pclmul, 0); 653| 0| if (ret < 0) { ------------------ | Branch (653:9): [True: 0, False: 0] ------------------ 654| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 655| 0| } 656| | 657| 0| ret = 658| 0| gnutls_crypto_single_cipher_register 659| 0| (GNUTLS_CIPHER_AES_256_GCM, 80, 660| 0| &_gnutls_aes_gcm_pclmul, 0); 661| 0| if (ret < 0) { ------------------ | Branch (661:9): [True: 0, False: 0] ------------------ 662| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 663| 0| } 664| 0| } 665| 0| } else 666| 0|# endif 667| 0| { 668| 0| ret = 669| 0| gnutls_crypto_single_cipher_register 670| 0| (GNUTLS_CIPHER_AES_128_GCM, 80, 671| 0| &_gnutls_aes_gcm_x86_aesni, 0); 672| 0| if (ret < 0) { ------------------ | Branch (672:8): [True: 0, False: 0] ------------------ 673| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 674| 0| } 675| | 676| 0| ret = 677| 0| gnutls_crypto_single_cipher_register 678| 0| (GNUTLS_CIPHER_AES_192_GCM, 80, 679| 0| &_gnutls_aes_gcm_x86_aesni, 0); 680| 0| if (ret < 0) { ------------------ | Branch (680:8): [True: 0, False: 0] ------------------ 681| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 682| 0| } 683| | 684| 0| ret = 685| 0| gnutls_crypto_single_cipher_register 686| 0| (GNUTLS_CIPHER_AES_256_GCM, 80, 687| 0| &_gnutls_aes_gcm_x86_aesni, 0); 688| 0| if (ret < 0) { ------------------ | Branch (688:8): [True: 0, False: 0] ------------------ 689| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 690| 0| } 691| 0| } 692| 0| } 693| | 694| 0| if (check_padlock(edx)) { ------------------ | Branch (694:6): [True: 0, False: 0] ------------------ 695| 0| _gnutls_debug_log("Padlock AES accelerator was detected\n"); ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 696| 0| ret = 697| 0| gnutls_crypto_single_cipher_register 698| 0| (GNUTLS_CIPHER_AES_128_CBC, 80, &_gnutls_aes_padlock, 0); 699| 0| if (ret < 0) { ------------------ | Branch (699:7): [True: 0, False: 0] ------------------ 700| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 701| 0| } 702| | 703| 0| ret = 704| 0| gnutls_crypto_single_cipher_register 705| 0| (GNUTLS_CIPHER_AES_192_CBC, 80, &_gnutls_aes_padlock, 0); 706| 0| if (ret < 0) { ------------------ | Branch (706:7): [True: 0, False: 0] ------------------ 707| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 708| 0| } 709| | 710| | /* register GCM ciphers */ 711| 0| ret = 712| 0| gnutls_crypto_single_cipher_register 713| 0| (GNUTLS_CIPHER_AES_128_GCM, 90, 714| 0| &_gnutls_aes_gcm_padlock, 0); 715| 0| if (ret < 0) { ------------------ | Branch (715:7): [True: 0, False: 0] ------------------ 716| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 717| 0| } 718| | 719| 0| ret = 720| 0| gnutls_crypto_single_cipher_register 721| 0| (GNUTLS_CIPHER_AES_256_CBC, 80, &_gnutls_aes_padlock, 0); 722| 0| if (ret < 0) { ------------------ | Branch (722:7): [True: 0, False: 0] ------------------ 723| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 724| 0| } 725| | 726| 0| ret = 727| 0| gnutls_crypto_single_cipher_register 728| 0| (GNUTLS_CIPHER_AES_256_GCM, 90, 729| 0| &_gnutls_aes_gcm_padlock, 0); 730| 0| if (ret < 0) { ------------------ | Branch (730:7): [True: 0, False: 0] ------------------ 731| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 732| 0| } 733| 0| } 734| | 735| 0| if (!check_optimized_aes() && !check_padlock(edx)) ------------------ | Branch (735:6): [True: 0, False: 0] | Branch (735:32): [True: 0, False: 0] ------------------ 736| 0| _gnutls_priority_update_non_aesni(); 737| | 738| 0|# ifdef HAVE_LIBNETTLE 739| 0| phe = check_phe(edx); 740| | 741| 0| if (phe && check_phe_partial()) { ------------------ | Branch (741:6): [True: 0, False: 0] | Branch (741:13): [True: 0, False: 0] ------------------ 742| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 743| 0| ("Padlock SHA1 and SHA256 (partial) accelerator was detected\n"); 744| 0| if (check_phe_sha512(edx)) { ------------------ | Branch (744:7): [True: 0, False: 0] ------------------ 745| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 746| 0| ("Padlock SHA512 (partial) accelerator was detected\n"); 747| 0| ret = 748| 0| gnutls_crypto_single_digest_register 749| 0| (GNUTLS_DIG_SHA384, 80, &_gnutls_sha_padlock, 0); 750| 0| if (ret < 0) { ------------------ | Branch (750:8): [True: 0, False: 0] ------------------ 751| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 752| 0| } 753| | 754| 0| ret = 755| 0| gnutls_crypto_single_digest_register 756| 0| (GNUTLS_DIG_SHA512, 80, &_gnutls_sha_padlock, 0); 757| 0| if (ret < 0) { ------------------ | Branch (757:8): [True: 0, False: 0] ------------------ 758| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 759| 0| } 760| | 761| 0| ret = 762| 0| gnutls_crypto_single_mac_register 763| 0| (GNUTLS_MAC_SHA384, 80, 764| 0| &_gnutls_hmac_sha_padlock, 0); 765| 0| if (ret < 0) { ------------------ | Branch (765:8): [True: 0, False: 0] ------------------ 766| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 767| 0| } 768| | 769| 0| ret = 770| 0| gnutls_crypto_single_mac_register 771| 0| (GNUTLS_MAC_SHA512, 80, 772| 0| &_gnutls_hmac_sha_padlock, 0); 773| 0| if (ret < 0) { ------------------ | Branch (773:8): [True: 0, False: 0] ------------------ 774| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 775| 0| } 776| 0| } 777| | 778| 0| ret = 779| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA1, 780| 0| 90, 781| 0| &_gnutls_sha_padlock, 782| 0| 0); 783| 0| if (ret < 0) { ------------------ | Branch (783:7): [True: 0, False: 0] ------------------ 784| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 785| 0| } 786| | 787| 0| ret = 788| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA224, 789| 0| 90, 790| 0| &_gnutls_sha_padlock, 791| 0| 0); 792| 0| if (ret < 0) { ------------------ | Branch (792:7): [True: 0, False: 0] ------------------ 793| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 794| 0| } 795| | 796| 0| ret = 797| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA256, 798| 0| 90, 799| 0| &_gnutls_sha_padlock, 800| 0| 0); 801| 0| if (ret < 0) { ------------------ | Branch (801:7): [True: 0, False: 0] ------------------ 802| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 803| 0| } 804| | 805| 0| ret = 806| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA1, 807| 0| 90, 808| 0| &_gnutls_hmac_sha_padlock, 809| 0| 0); 810| 0| if (ret < 0) { ------------------ | Branch (810:7): [True: 0, False: 0] ------------------ 811| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 812| 0| } 813| | 814| | /* we don't register MAC_SHA224 because it is not used by TLS */ 815| | 816| 0| ret = 817| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA256, 818| 0| 90, 819| 0| &_gnutls_hmac_sha_padlock, 820| 0| 0); 821| 0| if (ret < 0) { ------------------ | Branch (821:7): [True: 0, False: 0] ------------------ 822| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 823| 0| } 824| 0| } else if (phe) { ------------------ | Branch (824:13): [True: 0, False: 0] ------------------ 825| | /* Original padlock PHE. Does not support incremental operations. 826| | */ 827| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 828| 0| ("Padlock SHA1 and SHA256 accelerator was detected\n"); 829| 0| ret = 830| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA1, 831| 0| 90, 832| 0| &_gnutls_sha_padlock_oneshot, 833| 0| 0); 834| 0| if (ret < 0) { ------------------ | Branch (834:7): [True: 0, False: 0] ------------------ 835| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 836| 0| } 837| | 838| 0| ret = 839| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA256, 840| 0| 90, 841| 0| &_gnutls_sha_padlock_oneshot, 842| 0| 0); 843| 0| if (ret < 0) { ------------------ | Branch (843:7): [True: 0, False: 0] ------------------ 844| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 845| 0| } 846| | 847| 0| ret = 848| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA1, 849| 0| 90, 850| 0| &_gnutls_hmac_sha_padlock_oneshot, 851| 0| 0); 852| 0| if (ret < 0) { ------------------ | Branch (852:7): [True: 0, False: 0] ------------------ 853| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 854| 0| } 855| | 856| 0| ret = 857| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA256, 858| 0| 90, 859| 0| &_gnutls_hmac_sha_padlock_oneshot, 860| 0| 0); 861| 0| if (ret < 0) { ------------------ | Branch (861:7): [True: 0, False: 0] ------------------ 862| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 863| 0| } 864| 0| } 865| 0|# endif 866| | 867| 0| return; 868| 0|} x86-common.c:check_zhaoxin: 364| 2|{ 365| 2| unsigned int a, b, c, d; 366| | 367| 2| if (!__get_cpuid(0, &a, &b, &c, &d)) ------------------ | Branch (367:6): [True: 0, False: 2] ------------------ 368| 0| return 0; 369| | 370| | /* Zhaoxin and VIA CPU was detected */ 371| 2| if ((memcmp(&b, "Cent", 4) == 0 && ------------------ | Branch (371:7): [True: 0, False: 2] ------------------ 372| 2| memcmp(&d, "aurH", 4) == 0 && ------------------ | Branch (372:7): [True: 0, False: 0] ------------------ 373| 2| memcmp(&c, "auls", 4) == 0) || ------------------ | Branch (373:7): [True: 0, False: 0] ------------------ 374| 2| (memcmp(&b, " Sh", 4) == 0 && ------------------ | Branch (374:7): [True: 0, False: 2] ------------------ 375| 2| memcmp(&d, "angh", 4) == 0 && memcmp(&c, "ai ", 4) == 0)) { ------------------ | Branch (375:7): [True: 0, False: 0] | Branch (375:37): [True: 0, False: 0] ------------------ 376| 0| return 1; 377| 0| } 378| | 379| 2| return 0; 380| 2|} _gnutls_register_fork_handler: 51| 2|{ 52| 2| if (__register_atfork(NULL, NULL, fork_handler, __dso_handle) != 0) ------------------ | Branch (52:6): [True: 0, False: 2] ------------------ 53| 0| return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 54| 2| return 0; 55| 2|} gnutls_crypto_single_cipher_register: 180| 36|{ 181| | /* we override const in case free_s is set */ 182| 36| return _algo_register(&glob_cl, algorithm, priority, (void *)s, free_s); 183| 36|} gnutls_crypto_single_mac_register: 359| 10|{ 360| 10| return _algo_register(&glob_ml, algorithm, priority, (void *)s, free_s); 361| 10|} gnutls_crypto_single_digest_register: 394| 10|{ 395| 10| return _algo_register(&glob_dl, algorithm, priority, (void *)s, free_s); 396| 10|} crypto-backend.c:_algo_register: 52| 56|{ 53| 56| algo_list *cl; 54| 56| algo_list *last_cl = al; 55| 56| int ret; 56| | 57| 56| if (al == NULL) { ------------------ | Branch (57:6): [True: 0, False: 56] ------------------ 58| 0| ret = gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 59| 0| goto cleanup; 60| 0| } 61| | 62| | /* look if there is any cipher with lowest priority. In that case do not add. 63| | */ 64| 56| cl = al; 65| 258| while (cl && cl->alg_data) { ------------------ | Branch (65:9): [True: 258, False: 0] | Branch (65:15): [True: 214, False: 44] ------------------ 66| 214| if (cl->algorithm == algorithm) { ------------------ | Branch (66:7): [True: 12, False: 202] ------------------ 67| 12| if (cl->priority < priority) { ------------------ | Branch (67:8): [True: 0, False: 12] ------------------ 68| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 69| 0| ret = GNUTLS_E_CRYPTO_ALREADY_REGISTERED; ------------------ | | 3522| 0|# define GNUTLS_E_CRYPTO_ALREADY_REGISTERED GNUTLS_E_ALREADY_REGISTERED | | ------------------ | | | | 3523| 0|# define GNUTLS_E_ALREADY_REGISTERED -209 | | ------------------ ------------------ 70| 0| goto cleanup; 71| 12| } else { 72| | /* the current has higher priority -> overwrite */ 73| 12| cl->algorithm = algorithm; 74| 12| cl->priority = priority; 75| 12| cl->alg_data = s; 76| 12| cl->free_alg_data = free_s; 77| 12| return 0; 78| 12| } 79| 12| } 80| 202| cl = cl->next; 81| 202| if (cl) ------------------ | Branch (81:7): [True: 202, False: 0] ------------------ 82| 202| last_cl = cl; 83| 202| } 84| | 85| 44| cl = gnutls_calloc(1, sizeof(cipher_list)); 86| | 87| 44| if (cl == NULL) { ------------------ | Branch (87:6): [True: 0, False: 44] ------------------ 88| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 89| 0| ret = GNUTLS_E_MEMORY_ERROR; ------------------ | | 3406| 0|# define GNUTLS_E_MEMORY_ERROR -25 ------------------ 90| 0| goto cleanup; 91| 0| } 92| | 93| 44| last_cl->algorithm = algorithm; 94| 44| last_cl->priority = priority; 95| 44| last_cl->alg_data = s; 96| 44| last_cl->free_alg_data = free_s; 97| 44| last_cl->next = cl; 98| | 99| 44| return 0; 100| 0| cleanup: 101| 0| if (free_s) ------------------ | Branch (101:6): [True: 0, False: 0] ------------------ 102| 0| gnutls_free(s); ------------------ | | 2296| 0|# define gnutls_free(a) gnutls_free((void *) (a)), a=NULL ------------------ 103| 0| return ret; 104| 44|} global.c:_gnutls_switch_lib_state: 48| 4|{ 49| | /* Once into zombie state no errors can change us */ 50| 4| _gnutls_lib_state = state; 51| 4|} _gnutls_global_init_skip: 60| 2|{ 61| 2| return 0; 62| 2|} global.c:lib_init: 488| 2|{ 489| 2| int ret; 490| 2| const char *e; 491| | 492| 2| if (_gnutls_global_init_skip() != 0) ------------------ | Branch (492:6): [True: 0, False: 2] ------------------ 493| 0| return; 494| | 495| 2| e = secure_getenv("GNUTLS_NO_IMPLICIT_INIT"); 496| 2| if (e != NULL) { ------------------ | Branch (496:6): [True: 0, False: 2] ------------------ 497| 0| ret = atoi(e); 498| 0| if (ret == 1) ------------------ | Branch (498:7): [True: 0, False: 0] ------------------ 499| 0| return; 500| 0| } 501| | 502| 2| e = secure_getenv("GNUTLS_NO_EXPLICIT_INIT"); 503| 2| if (e != NULL) { ------------------ | Branch (503:6): [True: 0, False: 2] ------------------ 504| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 505| 0| ("GNUTLS_NO_EXPLICIT_INIT is deprecated; use GNUTLS_NO_IMPLICIT_INIT\n"); 506| 0| ret = atoi(e); 507| 0| if (ret == 1) ------------------ | Branch (507:7): [True: 0, False: 0] ------------------ 508| 0| return; 509| 0| } 510| | 511| 2| ret = _gnutls_global_init(1); 512| 2| if (ret < 0) { ------------------ | Branch (512:6): [True: 0, False: 2] ------------------ 513| 0| fprintf(stderr, "Error in GnuTLS initialization: %s\n", 514| 0| gnutls_strerror(ret)); 515| 0| _gnutls_switch_lib_state(LIB_STATE_ERROR); 516| 0| } 517| 2|} global.c:_gnutls_global_init: 228| 2|{ 229| 2| int ret = 0, res; 230| 2| int level; 231| 2| const char *e; 232| | 233| 2| if (!constructor) { ------------------ | Branch (233:6): [True: 0, False: 2] ------------------ 234| 0| ret = gnutls_static_mutex_lock(&global_init_mutex); ------------------ | | 45| 0| (unlikely(glthread_lock_lock(LOCK)) ? \ | | ------------------ | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (73:26): [True: 0, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 46| 0| gnutls_assert_val(GNUTLS_E_LOCKING_ERROR) : 0) | | ------------------ | | | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) | | ------------------ ------------------ 235| 0| if (ret < 0) { ------------------ | Branch (235:7): [True: 0, False: 0] ------------------ 236| 0| return gnutls_assert_val(ret); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 237| 0| } 238| 0| } 239| | 240| 2| _gnutls_init++; 241| 2| if (_gnutls_init > 1) { ------------------ | Branch (241:6): [True: 0, False: 2] ------------------ 242| 0| ret = _gnutls_init_ret; 243| 0| goto out; 244| 0| } 245| | 246| 2| _gnutls_switch_lib_state(LIB_STATE_INIT); 247| | 248| 2| e = secure_getenv("GNUTLS_DEBUG_LEVEL"); 249| 2| if (e != NULL) { ------------------ | Branch (249:6): [True: 0, False: 2] ------------------ 250| 0| level = atoi(e); 251| 0| gnutls_global_set_log_level(level); 252| 0| if (_gnutls_log_func == NULL) ------------------ | Branch (252:7): [True: 0, False: 0] ------------------ 253| 0| gnutls_global_set_log_function(default_log_func); 254| 0| _gnutls_debug_log("Enabled GnuTLS " VERSION " logging...\n"); ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 255| 0| } 256| | 257| 2|#ifdef HAVE_DCGETTEXT 258| 2| bindtextdomain(PACKAGE, LOCALEDIR); ------------------ | | 1835| 2|#define PACKAGE "gnutls" ------------------ 259| 2|#endif 260| | 261| 2| res = gnutls_crypto_init(); 262| 2| if (res != 0) { ------------------ | Branch (262:6): [True: 0, False: 2] ------------------ 263| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 264| 0| ret = GNUTLS_E_CRYPTO_INIT_FAILED; ------------------ | | 3561| 0|# define GNUTLS_E_CRYPTO_INIT_FAILED -318 ------------------ 265| 0| goto out; 266| 0| } 267| | 268| 2| ret = _gnutls_system_key_init(); 269| 2| if (ret != 0) { ------------------ | Branch (269:6): [True: 0, False: 2] ------------------ 270| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 271| 0| } 272| | 273| | /* initialize ASN.1 parser 274| | */ 275| 2| if (asn1_check_version(GNUTLS_MIN_LIBTASN1_VERSION) == NULL) { ------------------ | | 45| 2|#define GNUTLS_MIN_LIBTASN1_VERSION "0.3.4" ------------------ | Branch (275:6): [True: 0, False: 2] ------------------ 276| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 277| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 278| 0| ("Checking for libtasn1 failed: %s < %s\n", 279| 0| asn1_check_version(NULL), GNUTLS_MIN_LIBTASN1_VERSION); 280| 0| ret = GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY; ------------------ | | 3512| 0|# define GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY -203 ------------------ 281| 0| goto out; 282| 0| } 283| | 284| 2| _gnutls_pkix1_asn = NULL; 285| 2| res = asn1_array2tree(pkix_asn1_tab, &_gnutls_pkix1_asn, NULL); 286| 2| if (res != ASN1_SUCCESS) { ------------------ | | 116| 2|# define ASN1_SUCCESS 0 ------------------ | Branch (286:6): [True: 0, False: 2] ------------------ 287| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 288| 0| ret = _gnutls_asn2err(res); 289| 0| goto out; 290| 0| } 291| | 292| 2| res = asn1_array2tree(gnutls_asn1_tab, &_gnutls_gnutls_asn, NULL); 293| 2| if (res != ASN1_SUCCESS) { ------------------ | | 116| 2|# define ASN1_SUCCESS 0 ------------------ | Branch (293:6): [True: 0, False: 2] ------------------ 294| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 295| 0| ret = _gnutls_asn2err(res); 296| 0| goto out; 297| 0| } 298| | 299| | /* Initialize the random generator */ 300| 2| ret = _gnutls_rnd_preinit(); 301| 2| if (ret < 0) { ------------------ | Branch (301:6): [True: 0, False: 2] ------------------ 302| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 303| 0| goto out; 304| 0| } 305| | 306| | /* Initialize the default TLS extensions */ 307| 2| ret = _gnutls_hello_ext_init(); 308| 2| if (ret < 0) { ------------------ | Branch (308:6): [True: 0, False: 2] ------------------ 309| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 310| 0| goto out; 311| 0| } 312| | 313| 2| ret = gnutls_system_global_init(); 314| 2| if (ret < 0) { ------------------ | Branch (314:6): [True: 0, False: 2] ------------------ 315| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 316| 0| goto out; 317| 0| } 318| | 319| 2|#ifndef _WIN32 320| 2| ret = _gnutls_register_fork_handler(); 321| 2| if (ret < 0) { ------------------ | Branch (321:6): [True: 0, False: 2] ------------------ 322| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 323| 0| goto out; 324| 0| } 325| 2|#endif 326| | 327| |#ifdef ENABLE_FIPS140 328| | res = _gnutls_fips_mode_enabled(); 329| | /* res == 1 -> fips140-2 mode enabled 330| | * res == 2 -> only self checks performed - but no failure 331| | * res == not in fips140 mode 332| | */ 333| | if (res != 0) { 334| | _gnutls_debug_log("FIPS140-2 mode: %d\n", res); 335| | _gnutls_priority_update_fips(); 336| | 337| | /* first round of self checks, these are done on the 338| | * nettle algorithms which are used internally */ 339| | _gnutls_switch_lib_state(LIB_STATE_SELFTEST); 340| | ret = _gnutls_fips_perform_self_checks1(); 341| | if (ret < 0) { 342| | _gnutls_switch_lib_state(LIB_STATE_ERROR); 343| | _gnutls_audit_log(NULL, 344| | "FIPS140-2 self testing part1 failed\n"); 345| | if (res != 2) { 346| | gnutls_assert(); 347| | goto out; 348| | } 349| | } 350| | } 351| |#endif 352| | 353| 2| _gnutls_register_accel_crypto(); 354| 2| _gnutls_cryptodev_init(); 355| 2| _gnutls_afalg_init(); 356| | 357| |#ifdef ENABLE_FIPS140 358| | /* These self tests are performed on the overridden algorithms 359| | * (e.g., AESNI overridden AES). They are after _gnutls_register_accel_crypto() 360| | * intentionally */ 361| | if (res != 0) { 362| | _gnutls_switch_lib_state(LIB_STATE_SELFTEST); 363| | ret = _gnutls_fips_perform_self_checks2(); 364| | if (ret < 0) { 365| | _gnutls_switch_lib_state(LIB_STATE_ERROR); 366| | _gnutls_audit_log(NULL, 367| | "FIPS140-2 self testing part 2 failed\n"); 368| | if (res != 2) { 369| | gnutls_assert(); 370| | goto out; 371| | } 372| | } 373| | _gnutls_fips_mode_reset_zombie(); 374| | } 375| |#endif 376| 2| _gnutls_prepare_to_load_system_priorities(); 377| 2| _gnutls_switch_lib_state(LIB_STATE_OPERATIONAL); 378| 2| ret = 0; 379| | 380| 2| out: 381| 2| _gnutls_init_ret = ret; 382| 2| if (!constructor) { ------------------ | Branch (382:6): [True: 0, False: 2] ------------------ 383| 0| (void)gnutls_static_mutex_unlock(&global_init_mutex); ------------------ | | 49| 0| (unlikely(glthread_lock_unlock(LOCK)) ? \ | | ------------------ | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (73:26): [True: 0, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 50| 0| gnutls_assert_val(GNUTLS_E_LOCKING_ERROR) : 0) | | ------------------ | | | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) | | ------------------ ------------------ 384| 0| } 385| 2| return ret; 386| 2|} _gnutls_hello_ext_init: 477| 2|{ 478| 2| return GNUTLS_E_SUCCESS; ------------------ | | 3388| 2|# define GNUTLS_E_SUCCESS 0 ------------------ 479| 2|} _asn1_str_cat: 33| 532|{ 34| 532| size_t str_size = strlen (src); 35| 532| size_t dest_size = strlen (dest); 36| | 37| 532| if (dest_tot_size - dest_size > str_size) ------------------ | Branch (37:7): [True: 532, False: 0] ------------------ 38| 532| { 39| 532| strcat (dest, src); 40| 532| } 41| 0| else 42| 0| { 43| 0| if (dest_tot_size > dest_size) ------------------ | Branch (43:11): [True: 0, False: 0] ------------------ 44| 0| { 45| 0| strncat (dest, src, (dest_tot_size - dest_size) - 1); 46| 0| dest[dest_tot_size - 1] = 0; 47| 0| } 48| 0| } 49| 532|} _asn1_str_cpy: 54| 1.43k|{ 55| 1.43k| size_t str_size = strlen (src); 56| | 57| 1.43k| if (dest_tot_size > str_size) ------------------ | Branch (57:7): [True: 1.43k, False: 0] ------------------ 58| 1.43k| { 59| 1.43k| strcpy (dest, src); 60| 1.43k| return str_size; 61| 1.43k| } 62| 0| else 63| 0| { 64| 0| if (dest_tot_size > 0) ------------------ | Branch (64:11): [True: 0, False: 0] ------------------ 65| 0| { 66| 0| str_size = dest_tot_size - 1; 67| 0| memcpy (dest, src, str_size); 68| 0| dest[str_size] = 0; 69| 0| return str_size; 70| 0| } 71| 0| else 72| 0| return 0; 73| 0| } 74| 1.43k|} parser_aux.c:type_field: 179| 5.64k|{ 180| 5.64k| return (ntype & 0xff); 181| 5.64k|} structure.c:convert_old_type: 186| 1.14k|{ 187| 1.14k| unsigned int type = ntype & 0xff; 188| 1.14k| if (type == ASN1_ETYPE_TIME) ------------------ | | 172| 1.14k|# define ASN1_ETYPE_TIME 17 ------------------ | Branch (188:7): [True: 0, False: 1.14k] ------------------ 189| 0| { 190| 0| if (ntype & CONST_UTC) ------------------ | | 160| 0|# define CONST_UTC (1U<<24) ------------------ | Branch (190:11): [True: 0, False: 0] ------------------ 191| 0| type = ASN1_ETYPE_UTC_TIME; ------------------ | | 244| 0|# define ASN1_ETYPE_UTC_TIME 36 ------------------ 192| 0| else 193| 0| type = ASN1_ETYPE_GENERALIZED_TIME; ------------------ | | 245| 0|# define ASN1_ETYPE_GENERALIZED_TIME 37 ------------------ 194| | 195| 0| ntype &= ~(CONST_UTC | CONST_GENERALIZED); ------------------ | | 160| 0|# define CONST_UTC (1U<<24) ------------------ ntype &= ~(CONST_UTC | CONST_GENERALIZED); ------------------ | | 159| 0|# define CONST_GENERALIZED (1U<<23) ------------------ 196| 0| ntype &= 0xffffff00; 197| 0| ntype |= type; 198| | 199| 0| return ntype; 200| 0| } 201| 1.14k| else 202| 1.14k| return ntype; 203| 1.14k|} _asn1_add_static_node: 66| 1.14k|{ 67| 1.14k| list_type *p; 68| 1.14k| asn1_node punt; 69| | 70| 1.14k| punt = calloc (1, sizeof (struct asn1_node_st)); 71| 1.14k| if (punt == NULL) ------------------ | Branch (71:7): [True: 0, False: 1.14k] ------------------ 72| 0| return NULL; 73| | 74| 1.14k| p = malloc (sizeof (list_type)); 75| 1.14k| if (p == NULL) ------------------ | Branch (75:7): [True: 0, False: 1.14k] ------------------ 76| 0| { 77| 0| free (punt); 78| 0| return NULL; 79| 0| } 80| | 81| 1.14k| p->node = punt; 82| 1.14k| p->next = *e_list; 83| 1.14k| *e_list = p; 84| | 85| 1.14k| punt->type = type; 86| | 87| 1.14k| return punt; 88| 1.14k|} asn1_find_node: 122| 266|{ 123| 266| asn1_node_const p; 124| 266| char *n_end, n[ASN1_MAX_NAME_SIZE + 1]; 125| 266| const char *n_start; 126| 266| unsigned int nsize; 127| 266| unsigned int nhash; 128| | 129| 266| if (pointer == NULL) ------------------ | Branch (129:7): [True: 0, False: 266] ------------------ 130| 0| return NULL; 131| | 132| 266| if (name == NULL) ------------------ | Branch (132:7): [True: 0, False: 266] ------------------ 133| 0| return NULL; 134| | 135| 266| p = pointer; 136| 266| n_start = name; 137| | 138| 266| if (name[0] == '?' && name[1] == 'C' && p->name[0] == '?') ------------------ | Branch (138:7): [True: 0, False: 266] | Branch (138:25): [True: 0, False: 0] | Branch (138:43): [True: 0, False: 0] ------------------ 139| 0| { /* ?CURRENT */ 140| 0| n_start = strchr (n_start, '.'); 141| 0| if (n_start) ------------------ | Branch (141:11): [True: 0, False: 0] ------------------ 142| 0| n_start++; 143| 0| } 144| 266| else if (p->name[0] != 0) ------------------ | Branch (144:12): [True: 266, False: 0] ------------------ 145| 266| { /* has *pointer got a name ? */ 146| 266| n_end = strchr (n_start, '.'); /* search the first dot */ 147| 266| if (n_end) ------------------ | Branch (147:11): [True: 266, False: 0] ------------------ 148| 266| { 149| 266| nsize = n_end - n_start; 150| 266| if (nsize >= sizeof (n)) ------------------ | Branch (150:8): [True: 0, False: 266] ------------------ 151| 0| return NULL; 152| | 153| 266| memcpy (n, n_start, nsize); 154| 266| n[nsize] = 0; 155| 266| n_start = n_end; 156| 266| n_start++; 157| | 158| 266| nhash = _asn1_hash_name (n); 159| 266| } 160| 0| else 161| 0| { 162| 0| _asn1_str_cpy (n, sizeof (n), n_start); 163| 0| nhash = _asn1_hash_name (n); 164| | 165| 0| n_start = NULL; 166| 0| } 167| | 168| 266| while (p) ------------------ | Branch (168:14): [True: 266, False: 0] ------------------ 169| 266| { 170| 266| if (nhash == p->name_hash && (!strcmp (p->name, n))) ------------------ | Branch (170:8): [True: 266, False: 0] | Branch (170:33): [True: 266, False: 0] ------------------ 171| 266| break; 172| 0| else 173| 0| p = p->right; 174| 266| } /* while */ 175| | 176| 266| if (p == NULL) ------------------ | Branch (176:11): [True: 0, False: 266] ------------------ 177| 0| return NULL; 178| 266| } 179| 0| else 180| 0| { /* *pointer doesn't have a name */ 181| 0| if (n_start[0] == 0) ------------------ | Branch (181:11): [True: 0, False: 0] ------------------ 182| 0| return (asn1_node) p; 183| 0| } 184| | 185| 532| while (n_start) ------------------ | Branch (185:10): [True: 266, False: 266] ------------------ 186| 266| { /* Has the end of NAME been reached? */ 187| 266| n_end = strchr (n_start, '.'); /* search the next dot */ 188| 266| if (n_end) ------------------ | Branch (188:11): [True: 0, False: 266] ------------------ 189| 0| { 190| 0| nsize = n_end - n_start; 191| 0| if (nsize >= sizeof (n)) ------------------ | Branch (191:8): [True: 0, False: 0] ------------------ 192| 0| return NULL; 193| | 194| 0| memcpy (n, n_start, nsize); 195| 0| n[nsize] = 0; 196| 0| n_start = n_end; 197| 0| n_start++; 198| | 199| 0| nhash = _asn1_hash_name (n); 200| 0| } 201| 266| else 202| 266| { 203| 266| _asn1_str_cpy (n, sizeof (n), n_start); 204| 266| nhash = _asn1_hash_name (n); 205| 266| n_start = NULL; 206| 266| } 207| | 208| 266| if (p->down == NULL) ------------------ | Branch (208:11): [True: 0, False: 266] ------------------ 209| 0| return NULL; 210| | 211| 266| p = p->down; 212| 266| if (p == NULL) ------------------ | Branch (212:11): [True: 0, False: 266] ------------------ 213| 0| return NULL; 214| | 215| | /* The identifier "?LAST" indicates the last element 216| | in the right chain. */ 217| 266| if (n[0] == '?' && n[1] == 'L') /* ?LAST */ ------------------ | Branch (217:11): [True: 0, False: 266] | Branch (217:26): [True: 0, False: 0] ------------------ 218| 0| { 219| 0| while (p->right) ------------------ | Branch (219:11): [True: 0, False: 0] ------------------ 220| 0| p = p->right; 221| 0| } 222| 266| else 223| 266| { /* no "?LAST" */ 224| 11.1k| while (p) ------------------ | Branch (224:11): [True: 11.1k, False: 0] ------------------ 225| 11.1k| { 226| 11.1k| if (p->name_hash == nhash && !strcmp (p->name, n)) ------------------ | Branch (226:12): [True: 266, False: 10.8k] | Branch (226:37): [True: 266, False: 0] ------------------ 227| 266| break; 228| 10.8k| else 229| 10.8k| p = p->right; 230| 11.1k| } 231| 266| } 232| 266| if (p == NULL) ------------------ | Branch (232:11): [True: 0, False: 266] ------------------ 233| 0| return NULL; 234| 266| } /* while */ 235| | 236| 266| return (asn1_node) p; 237| 266|} _asn1_set_value: 252| 462|{ 253| 462| if (node == NULL) ------------------ | Branch (253:7): [True: 0, False: 462] ------------------ 254| 0| return node; 255| 462| if (node->value) ------------------ | Branch (255:7): [True: 0, False: 462] ------------------ 256| 0| { 257| 0| if (node->value != node->small_value) ------------------ | Branch (257:11): [True: 0, False: 0] ------------------ 258| 0| free (node->value); 259| 0| node->value = NULL; 260| 0| node->value_len = 0; 261| 0| } 262| | 263| 462| if (!len) ------------------ | Branch (263:7): [True: 0, False: 462] ------------------ 264| 0| return node; 265| | 266| 462| if (len < sizeof (node->small_value)) ------------------ | Branch (266:7): [True: 314, False: 148] ------------------ 267| 314| { 268| 314| node->value = node->small_value; 269| 314| } 270| 148| else 271| 148| { 272| 148| node->value = malloc (len); 273| 148| if (node->value == NULL) ------------------ | Branch (273:11): [True: 0, False: 148] ------------------ 274| 0| return NULL; 275| 148| } 276| 462| node->value_len = len; 277| | 278| 462| memcpy (node->value, value, len); 279| 462| return node; 280| 462|} _asn1_set_name: 409| 898|{ 410| 898| if (node == NULL) ------------------ | Branch (410:7): [True: 0, False: 898] ------------------ 411| 0| return node; 412| | 413| 898| _asn1_str_cpy (node->name, sizeof (node->name), name ? name : ""); ------------------ | Branch (413:51): [True: 898, False: 0] ------------------ 414| 898| node->name_hash = _asn1_hash_name (node->name); 415| | 416| 898| return node; 417| 898|} _asn1_set_right: 457| 714|{ 458| 714| if (node == NULL) ------------------ | Branch (458:7): [True: 0, False: 714] ------------------ 459| 0| return node; 460| 714| node->right = right; 461| 714| if (right) ------------------ | Branch (461:7): [True: 714, False: 0] ------------------ 462| 714| right->left = node; 463| 714| return node; 464| 714|} _asn1_find_up: 523| 2.12k|{ 524| 2.12k| asn1_node_const p; 525| | 526| 2.12k| if (node == NULL) ------------------ | Branch (526:7): [True: 0, False: 2.12k] ------------------ 527| 0| return NULL; 528| | 529| 2.12k| p = node; 530| | 531| 5.69k| while ((p->left != NULL) && (p->left->right == p)) ------------------ | Branch (531:10): [True: 5.69k, False: 0] | Branch (531:31): [True: 3.57k, False: 2.12k] ------------------ 532| 3.57k| p = p->left; 533| | 534| 2.12k| return p->left; 535| 2.12k|} _asn1_delete_list: 581| 4|{ 582| 4| list_type *p; 583| | 584| 1.14k| while (e_list) ------------------ | Branch (584:10): [True: 1.14k, False: 4] ------------------ 585| 1.14k| { 586| 1.14k| p = e_list; 587| 1.14k| e_list = e_list->next; 588| 1.14k| free (p); 589| 1.14k| } 590| 4|} _asn1_change_integer_value: 662| 4|{ 663| 4| asn1_node p; 664| 4| unsigned char val[SIZEOF_UNSIGNED_LONG_INT]; 665| 4| unsigned char val2[SIZEOF_UNSIGNED_LONG_INT + 1]; 666| 4| int len; 667| | 668| 4| if (node == NULL) ------------------ | Branch (668:7): [True: 0, False: 4] ------------------ 669| 0| return ASN1_ELEMENT_NOT_FOUND; ------------------ | | 118| 0|# define ASN1_ELEMENT_NOT_FOUND 2 ------------------ 670| | 671| 4| p = node; 672| 1.14k| while (p) ------------------ | Branch (672:10): [True: 1.14k, False: 4] ------------------ 673| 1.14k| { 674| 1.14k| if ((type_field (p->type) == ASN1_ETYPE_INTEGER) ------------------ | | 217| 1.14k|# define ASN1_ETYPE_INTEGER 3 ------------------ | Branch (674:11): [True: 124, False: 1.01k] ------------------ 675| 1.14k| && (p->type & CONST_ASSIGN)) ------------------ | | 166| 124|# define CONST_ASSIGN (1U<<28) ------------------ | Branch (675:7): [True: 0, False: 124] ------------------ 676| 0| { 677| 0| if (p->value) ------------------ | Branch (677:8): [True: 0, False: 0] ------------------ 678| 0| { 679| 0| _asn1_convert_integer (p->value, val, sizeof (val), &len); 680| 0| asn1_octet_der (val, len, val2, &len); 681| 0| _asn1_set_value (p, val2, len); 682| 0| } 683| 0| } 684| | 685| 1.14k| if (p->down) ------------------ | Branch (685:11): [True: 424, False: 718] ------------------ 686| 424| { 687| 424| p = p->down; 688| 424| } 689| 718| else 690| 718| { 691| 718| if (p == node) ------------------ | Branch (691:8): [True: 0, False: 718] ------------------ 692| 0| p = NULL; 693| 718| else if (p->right) ------------------ | Branch (693:13): [True: 392, False: 326] ------------------ 694| 392| p = p->right; 695| 326| else 696| 326| { 697| 424| while (1) ------------------ | Branch (697:15): [Folded - Ignored] ------------------ 698| 424| { 699| 424| p = _asn1_find_up (p); 700| 424| if (p == node) ------------------ | Branch (700:9): [True: 4, False: 420] ------------------ 701| 4| { 702| 4| p = NULL; 703| 4| break; 704| 4| } 705| 420| if (p && p->right) ------------------ | Branch (705:9): [True: 420, False: 0] | Branch (705:14): [True: 322, False: 98] ------------------ 706| 322| { 707| 322| p = p->right; 708| 322| break; 709| 322| } 710| 420| } 711| 326| } 712| 718| } 713| 1.14k| } 714| | 715| 4| return ASN1_SUCCESS; ------------------ | | 116| 4|# define ASN1_SUCCESS 0 ------------------ 716| 4|} _asn1_expand_object_id: 731| 4|{ 732| 4| asn1_node p, p2, p3, p4, p5; 733| 4| char name_root[ASN1_MAX_NAME_SIZE], name2[2 * ASN1_MAX_NAME_SIZE + 1]; 734| 4| int move, tlen, tries; 735| 4| unsigned max_constants; 736| | 737| 4| if (node == NULL) ------------------ | Branch (737:7): [True: 0, False: 4] ------------------ 738| 0| return ASN1_ELEMENT_NOT_FOUND; ------------------ | | 118| 0|# define ASN1_ELEMENT_NOT_FOUND 2 ------------------ 739| | 740| 4| _asn1_str_cpy (name_root, sizeof (name_root), node->name); 741| | 742| 4| p = node; 743| 4| move = DOWN; ------------------ | | 131| 4|# define DOWN 3 ------------------ 744| 4| tries = 0; 745| | 746| 1.56k| while (!((p == node) && (move == UP))) ------------------ | | 129| 8|# define UP 1 ------------------ | Branch (746:12): [True: 8, False: 1.55k] | Branch (746:27): [True: 4, False: 4] ------------------ 747| 1.56k| { 748| 1.56k| if (move != UP) ------------------ | | 129| 1.56k|# define UP 1 ------------------ | Branch (748:11): [True: 1.14k, False: 420] ------------------ 749| 1.14k| { 750| 1.14k| if ((type_field (p->type) == ASN1_ETYPE_OBJECT_ID) ------------------ | | 226| 1.14k|# define ASN1_ETYPE_OBJECT_ID 12 ------------------ | Branch (750:8): [True: 68, False: 1.07k] ------------------ 751| 1.14k| && (p->type & CONST_ASSIGN)) ------------------ | | 166| 68|# define CONST_ASSIGN (1U<<28) ------------------ | Branch (751:11): [True: 2, False: 66] ------------------ 752| 2| { 753| 2| p2 = p->down; 754| 2| if (p2 && (type_field (p2->type) == ASN1_ETYPE_CONSTANT)) ------------------ | | 215| 2|# define ASN1_ETYPE_CONSTANT 1 ------------------ | Branch (754:12): [True: 2, False: 0] | Branch (754:18): [True: 2, False: 0] ------------------ 755| 2| { 756| 2| if (p2->value && !c_isdigit (p2->value[0])) ------------------ | Branch (756:9): [True: 2, False: 0] | Branch (756:22): [True: 0, False: 2] ------------------ 757| 0| { 758| 0| _asn1_str_cpy (name2, sizeof (name2), name_root); 759| 0| _asn1_str_cat (name2, sizeof (name2), "."); 760| 0| _asn1_str_cat (name2, sizeof (name2), 761| 0| (char *) p2->value); 762| 0| p3 = asn1_find_node (node, name2); 763| 0| if (!p3 || _asn1_is_up (p2, p3) || ------------------ | Branch (763:13): [True: 0, False: 0] | Branch (763:20): [True: 0, False: 0] ------------------ 764| 0| (type_field (p3->type) != ASN1_ETYPE_OBJECT_ID) || ------------------ | | 226| 0|# define ASN1_ETYPE_OBJECT_ID 12 ------------------ | Branch (764:6): [True: 0, False: 0] ------------------ 765| 0| !(p3->type & CONST_ASSIGN)) ------------------ | | 166| 0|# define CONST_ASSIGN (1U<<28) ------------------ | Branch (765:6): [True: 0, False: 0] ------------------ 766| 0| return ASN1_ELEMENT_NOT_FOUND; ------------------ | | 118| 0|# define ASN1_ELEMENT_NOT_FOUND 2 ------------------ 767| | 768| 0| _asn1_set_down (p, p2->right); 769| 0| if (p2->down) ------------------ | Branch (769:13): [True: 0, False: 0] ------------------ 770| 0| _asn1_delete_structure (*list, &p2->down, 0); 771| 0| _asn1_delete_node_from_list (*list, p2); 772| 0| _asn1_remove_node (p2, 0); 773| 0| p2 = p; 774| 0| p4 = p3->down; 775| 0| max_constants = 0; 776| 0| while (p4) ------------------ | Branch (776:16): [True: 0, False: 0] ------------------ 777| 0| { 778| 0| if (type_field (p4->type) == ASN1_ETYPE_CONSTANT) ------------------ | | 215| 0|# define ASN1_ETYPE_CONSTANT 1 ------------------ | Branch (778:10): [True: 0, False: 0] ------------------ 779| 0| { 780| 0| max_constants++; 781| 0| if (max_constants == MAX_CONSTANTS) ------------------ | | 718| 0|#define MAX_CONSTANTS 1024 ------------------ | Branch (781:14): [True: 0, False: 0] ------------------ 782| 0| return ASN1_RECURSION; ------------------ | | 135| 0|# define ASN1_RECURSION 19 ------------------ 783| | 784| 0| p5 = 785| 0| _asn1_add_single_node (ASN1_ETYPE_CONSTANT); ------------------ | | 215| 0|# define ASN1_ETYPE_CONSTANT 1 ------------------ 786| 0| _asn1_set_name (p5, p4->name); 787| 0| if (p4->value) ------------------ | Branch (787:14): [True: 0, False: 0] ------------------ 788| 0| { 789| 0| tlen = _asn1_strlen (p4->value); ------------------ | | 113| 0|# define _asn1_strlen(s) strlen((const char *) s) ------------------ 790| 0| if (tlen > 0) ------------------ | Branch (790:11): [True: 0, False: 0] ------------------ 791| 0| _asn1_set_value (p5, p4->value, tlen + 1); 792| 0| } 793| 0| _asn1_add_static_node2 (list, p5); 794| | 795| 0| if (p2 == p) ------------------ | Branch (795:14): [True: 0, False: 0] ------------------ 796| 0| { 797| 0| _asn1_set_right (p5, p->down); 798| 0| _asn1_set_down (p, p5); 799| 0| } 800| 0| else 801| 0| { 802| 0| _asn1_set_right (p5, p2->right); 803| 0| _asn1_set_right (p2, p5); 804| 0| } 805| 0| p2 = p5; 806| 0| } 807| 0| p4 = p4->right; 808| 0| } 809| 0| move = DOWN; ------------------ | | 131| 0|# define DOWN 3 ------------------ 810| | 811| 0| tries++; 812| 0| if (tries >= EXPAND_OBJECT_ID_MAX_RECURSION) ------------------ | | 76| 0|# define EXPAND_OBJECT_ID_MAX_RECURSION 16 ------------------ | Branch (812:13): [True: 0, False: 0] ------------------ 813| 0| return ASN1_RECURSION; ------------------ | | 135| 0|# define ASN1_RECURSION 19 ------------------ 814| | 815| 0| continue; 816| 0| } 817| 2| } 818| 2| } 819| 1.14k| move = DOWN; ------------------ | | 131| 1.14k|# define DOWN 3 ------------------ 820| 1.14k| } 821| 420| else 822| 420| move = RIGHT; ------------------ | | 130| 420|# define RIGHT 2 ------------------ 823| | 824| 1.56k| tries = 0; 825| 1.56k| if (move == DOWN) ------------------ | | 131| 1.56k|# define DOWN 3 ------------------ | Branch (825:11): [True: 1.14k, False: 420] ------------------ 826| 1.14k| { 827| 1.14k| if (p->down) ------------------ | Branch (827:8): [True: 424, False: 718] ------------------ 828| 424| p = p->down; 829| 718| else 830| 718| move = RIGHT; ------------------ | | 130| 718|# define RIGHT 2 ------------------ 831| 1.14k| } 832| | 833| 1.56k| if (p == node) ------------------ | Branch (833:11): [True: 0, False: 1.56k] ------------------ 834| 0| { 835| 0| move = UP; ------------------ | | 129| 0|# define UP 1 ------------------ 836| 0| continue; 837| 0| } 838| | 839| 1.56k| if (move == RIGHT) ------------------ | | 130| 1.56k|# define RIGHT 2 ------------------ | Branch (839:11): [True: 1.13k, False: 424] ------------------ 840| 1.13k| { 841| 1.13k| if (p && p->right) ------------------ | Branch (841:8): [True: 1.13k, False: 0] | Branch (841:13): [True: 714, False: 424] ------------------ 842| 714| p = p->right; 843| 424| else 844| 424| move = UP; ------------------ | | 129| 424|# define UP 1 ------------------ 845| 1.13k| } 846| 1.56k| if (move == UP) ------------------ | | 129| 1.56k|# define UP 1 ------------------ | Branch (846:11): [True: 424, False: 1.13k] ------------------ 847| 424| p = _asn1_find_up (p); 848| 1.56k| } 849| | 850| | /*******************************/ 851| | /* expand DEFAULT */ 852| | /*******************************/ 853| 4| p = node; 854| 4| move = DOWN; ------------------ | | 131| 4|# define DOWN 3 ------------------ 855| | 856| 1.56k| while (!((p == node) && (move == UP))) ------------------ | | 129| 8|# define UP 1 ------------------ | Branch (856:12): [True: 8, False: 1.55k] | Branch (856:27): [True: 4, False: 4] ------------------ 857| 1.56k| { 858| 1.56k| if (move != UP) ------------------ | | 129| 1.56k|# define UP 1 ------------------ | Branch (858:11): [True: 1.14k, False: 420] ------------------ 859| 1.14k| { 860| 1.14k| if ((type_field (p->type) == ASN1_ETYPE_OBJECT_ID) && ------------------ | | 226| 1.14k|# define ASN1_ETYPE_OBJECT_ID 12 ------------------ | Branch (860:8): [True: 68, False: 1.07k] ------------------ 861| 1.14k| (p->type & CONST_DEFAULT)) ------------------ | | 145| 68|# define CONST_DEFAULT (1U<<15) ------------------ | Branch (861:8): [True: 0, False: 68] ------------------ 862| 0| { 863| 0| p2 = p->down; 864| 0| if (p2 && (type_field (p2->type) == ASN1_ETYPE_DEFAULT)) ------------------ | | 223| 0|# define ASN1_ETYPE_DEFAULT 9 ------------------ | Branch (864:12): [True: 0, False: 0] | Branch (864:18): [True: 0, False: 0] ------------------ 865| 0| { 866| 0| _asn1_str_cpy (name2, sizeof (name2), name_root); 867| 0| _asn1_str_cat (name2, sizeof (name2), "."); 868| 0| if (p2->value) ------------------ | Branch (868:9): [True: 0, False: 0] ------------------ 869| 0| _asn1_str_cat (name2, sizeof (name2), (char *) p2->value); 870| 0| p3 = asn1_find_node (node, name2); 871| 0| if (!p3 || (type_field (p3->type) != ASN1_ETYPE_OBJECT_ID) ------------------ | | 226| 0|# define ASN1_ETYPE_OBJECT_ID 12 ------------------ | Branch (871:9): [True: 0, False: 0] | Branch (871:16): [True: 0, False: 0] ------------------ 872| 0| || !(p3->type & CONST_ASSIGN)) ------------------ | | 166| 0|# define CONST_ASSIGN (1U<<28) ------------------ | Branch (872:12): [True: 0, False: 0] ------------------ 873| 0| return ASN1_ELEMENT_NOT_FOUND; ------------------ | | 118| 0|# define ASN1_ELEMENT_NOT_FOUND 2 ------------------ 874| 0| p4 = p3->down; 875| 0| name2[0] = 0; 876| 0| while (p4) ------------------ | Branch (876:12): [True: 0, False: 0] ------------------ 877| 0| { 878| 0| if (type_field (p4->type) == ASN1_ETYPE_CONSTANT) ------------------ | | 215| 0|# define ASN1_ETYPE_CONSTANT 1 ------------------ | Branch (878:13): [True: 0, False: 0] ------------------ 879| 0| { 880| 0| if (p4->value == NULL) ------------------ | Branch (880:10): [True: 0, False: 0] ------------------ 881| 0| return ASN1_VALUE_NOT_FOUND; ------------------ | | 121| 0|# define ASN1_VALUE_NOT_FOUND 5 ------------------ 882| | 883| 0| if (name2[0]) ------------------ | Branch (883:10): [True: 0, False: 0] ------------------ 884| 0| _asn1_str_cat (name2, sizeof (name2), "."); 885| 0| _asn1_str_cat (name2, sizeof (name2), 886| 0| (char *) p4->value); 887| 0| } 888| 0| p4 = p4->right; 889| 0| } 890| 0| tlen = strlen (name2); 891| 0| if (tlen > 0) ------------------ | Branch (891:9): [True: 0, False: 0] ------------------ 892| 0| _asn1_set_value (p2, name2, tlen + 1); 893| 0| } 894| 0| } 895| 1.14k| move = DOWN; ------------------ | | 131| 1.14k|# define DOWN 3 ------------------ 896| 1.14k| } 897| 420| else 898| 420| move = RIGHT; ------------------ | | 130| 420|# define RIGHT 2 ------------------ 899| | 900| 1.56k| if (move == DOWN) ------------------ | | 131| 1.56k|# define DOWN 3 ------------------ | Branch (900:11): [True: 1.14k, False: 420] ------------------ 901| 1.14k| { 902| 1.14k| if (p->down) ------------------ | Branch (902:8): [True: 424, False: 718] ------------------ 903| 424| p = p->down; 904| 718| else 905| 718| move = RIGHT; ------------------ | | 130| 718|# define RIGHT 2 ------------------ 906| 1.14k| } 907| | 908| 1.56k| if (p == node) ------------------ | Branch (908:11): [True: 0, False: 1.56k] ------------------ 909| 0| { 910| 0| move = UP; ------------------ | | 129| 0|# define UP 1 ------------------ 911| 0| continue; 912| 0| } 913| | 914| 1.56k| if (move == RIGHT) ------------------ | | 130| 1.56k|# define RIGHT 2 ------------------ | Branch (914:11): [True: 1.13k, False: 424] ------------------ 915| 1.13k| { 916| 1.13k| if (p && p->right) ------------------ | Branch (916:8): [True: 1.13k, False: 0] | Branch (916:13): [True: 714, False: 424] ------------------ 917| 714| p = p->right; 918| 424| else 919| 424| move = UP; ------------------ | | 129| 424|# define UP 1 ------------------ 920| 1.13k| } 921| 1.56k| if (move == UP) ------------------ | | 129| 1.56k|# define UP 1 ------------------ | Branch (921:11): [True: 424, False: 1.13k] ------------------ 922| 424| p = _asn1_find_up (p); 923| 1.56k| } 924| | 925| 4| return ASN1_SUCCESS; ------------------ | | 116| 4|# define ASN1_SUCCESS 0 ------------------ 926| 4|} _asn1_check_identifier: 1014| 4|{ 1015| 4| asn1_node_const p, p2; 1016| 4| char name2[ASN1_MAX_NAME_SIZE * 2 + 2]; 1017| | 1018| 4| if (node == NULL) ------------------ | Branch (1018:7): [True: 0, False: 4] ------------------ 1019| 0| return ASN1_ELEMENT_NOT_FOUND; ------------------ | | 118| 0|# define ASN1_ELEMENT_NOT_FOUND 2 ------------------ 1020| | 1021| 4| p = node; 1022| 1.14k| while (p) ------------------ | Branch (1022:10): [True: 1.14k, False: 4] ------------------ 1023| 1.14k| { 1024| 1.14k| if (p->value && type_field (p->type) == ASN1_ETYPE_IDENTIFIER) ------------------ | | 216| 462|# define ASN1_ETYPE_IDENTIFIER 2 ------------------ | Branch (1024:11): [True: 462, False: 680] | Branch (1024:23): [True: 266, False: 196] ------------------ 1025| 266| { 1026| 266| _asn1_str_cpy (name2, sizeof (name2), node->name); 1027| 266| _asn1_str_cat (name2, sizeof (name2), "."); 1028| 266| _asn1_str_cat (name2, sizeof (name2), (char *) p->value); 1029| 266| p2 = asn1_find_node (node, name2); 1030| 266| if (p2 == NULL) ------------------ | Branch (1030:8): [True: 0, False: 266] ------------------ 1031| 0| { 1032| 0| if (p->value) ------------------ | Branch (1032:12): [True: 0, False: 0] ------------------ 1033| 0| _asn1_str_cpy (_asn1_identifierMissing, 1034| 0| sizeof (_asn1_identifierMissing), 1035| 0| (char *) p->value); 1036| 0| else 1037| 0| _asn1_strcpy (_asn1_identifierMissing, "(null)"); ------------------ | | 117| 0|# define _asn1_strcpy(a,b) strcpy((char *)a, (const char *)b) ------------------ 1038| 0| return ASN1_IDENTIFIER_NOT_FOUND; ------------------ | | 119| 0|# define ASN1_IDENTIFIER_NOT_FOUND 3 ------------------ 1039| 0| } 1040| 266| } 1041| 876| else if ((type_field (p->type) == ASN1_ETYPE_OBJECT_ID) && ------------------ | | 226| 876|# define ASN1_ETYPE_OBJECT_ID 12 ------------------ | Branch (1041:16): [True: 68, False: 808] ------------------ 1042| 876| (p->type & CONST_DEFAULT)) ------------------ | | 145| 68|# define CONST_DEFAULT (1U<<15) ------------------ | Branch (1042:9): [True: 0, False: 68] ------------------ 1043| 0| { 1044| 0| p2 = p->down; 1045| 0| if (p2 && (type_field (p2->type) == ASN1_ETYPE_DEFAULT)) ------------------ | | 223| 0|# define ASN1_ETYPE_DEFAULT 9 ------------------ | Branch (1045:8): [True: 0, False: 0] | Branch (1045:14): [True: 0, False: 0] ------------------ 1046| 0| { 1047| 0| _asn1_str_cpy (name2, sizeof (name2), node->name); 1048| 0| if (p2->value) ------------------ | Branch (1048:12): [True: 0, False: 0] ------------------ 1049| 0| { 1050| 0| _asn1_str_cat (name2, sizeof (name2), "."); 1051| 0| _asn1_str_cat (name2, sizeof (name2), (char *) p2->value); 1052| 0| _asn1_str_cpy (_asn1_identifierMissing, 1053| 0| sizeof (_asn1_identifierMissing), 1054| 0| (char *) p2->value); 1055| 0| } 1056| 0| else 1057| 0| _asn1_strcpy (_asn1_identifierMissing, "(null)"); ------------------ | | 117| 0|# define _asn1_strcpy(a,b) strcpy((char *)a, (const char *)b) ------------------ 1058| | 1059| 0| p2 = asn1_find_node (node, name2); 1060| 0| if (!p2 || (type_field (p2->type) != ASN1_ETYPE_OBJECT_ID) || ------------------ | | 226| 0|# define ASN1_ETYPE_OBJECT_ID 12 ------------------ | Branch (1060:12): [True: 0, False: 0] | Branch (1060:19): [True: 0, False: 0] ------------------ 1061| 0| !(p2->type & CONST_ASSIGN)) ------------------ | | 166| 0|# define CONST_ASSIGN (1U<<28) ------------------ | Branch (1061:5): [True: 0, False: 0] ------------------ 1062| 0| return ASN1_IDENTIFIER_NOT_FOUND; ------------------ | | 119| 0|# define ASN1_IDENTIFIER_NOT_FOUND 3 ------------------ 1063| 0| else 1064| 0| _asn1_identifierMissing[0] = 0; 1065| 0| } 1066| 0| } 1067| 876| else if ((type_field (p->type) == ASN1_ETYPE_OBJECT_ID) && ------------------ | | 226| 876|# define ASN1_ETYPE_OBJECT_ID 12 ------------------ | Branch (1067:16): [True: 68, False: 808] ------------------ 1068| 876| (p->type & CONST_ASSIGN)) ------------------ | | 166| 68|# define CONST_ASSIGN (1U<<28) ------------------ | Branch (1068:9): [True: 2, False: 66] ------------------ 1069| 2| { 1070| 2| p2 = p->down; 1071| 2| if (p2 && (type_field (p2->type) == ASN1_ETYPE_CONSTANT)) ------------------ | | 215| 2|# define ASN1_ETYPE_CONSTANT 1 ------------------ | Branch (1071:8): [True: 2, False: 0] | Branch (1071:14): [True: 2, False: 0] ------------------ 1072| 2| { 1073| 2| if (p2->value && !c_isdigit (p2->value[0])) ------------------ | Branch (1073:12): [True: 2, False: 0] | Branch (1073:25): [True: 0, False: 2] ------------------ 1074| 0| { 1075| 0| _asn1_str_cpy (name2, sizeof (name2), node->name); 1076| 0| _asn1_str_cat (name2, sizeof (name2), "."); 1077| 0| _asn1_str_cat (name2, sizeof (name2), (char *) p2->value); 1078| 0| _asn1_str_cpy (_asn1_identifierMissing, 1079| 0| sizeof (_asn1_identifierMissing), 1080| 0| (char *) p2->value); 1081| | 1082| 0| p2 = asn1_find_node (node, name2); 1083| 0| if (!p2 || (type_field (p2->type) != ASN1_ETYPE_OBJECT_ID) ------------------ | | 226| 0|# define ASN1_ETYPE_OBJECT_ID 12 ------------------ | Branch (1083:9): [True: 0, False: 0] | Branch (1083:16): [True: 0, False: 0] ------------------ 1084| 0| || !(p2->type & CONST_ASSIGN)) ------------------ | | 166| 0|# define CONST_ASSIGN (1U<<28) ------------------ | Branch (1084:12): [True: 0, False: 0] ------------------ 1085| 0| return ASN1_IDENTIFIER_NOT_FOUND; ------------------ | | 119| 0|# define ASN1_IDENTIFIER_NOT_FOUND 3 ------------------ 1086| 0| else 1087| 0| _asn1_identifierMissing[0] = 0; 1088| 0| } 1089| 2| } 1090| 2| } 1091| | 1092| 1.14k| if (p->down) ------------------ | Branch (1092:11): [True: 424, False: 718] ------------------ 1093| 424| { 1094| 424| p = p->down; 1095| 424| } 1096| 718| else if (p->right) ------------------ | Branch (1096:16): [True: 392, False: 326] ------------------ 1097| 392| p = p->right; 1098| 326| else 1099| 326| { 1100| 424| while (p) ------------------ | Branch (1100:11): [True: 424, False: 0] ------------------ 1101| 424| { 1102| 424| p = _asn1_find_up (p); 1103| 424| if (p == node) ------------------ | Branch (1103:12): [True: 4, False: 420] ------------------ 1104| 4| { 1105| 4| p = NULL; 1106| 4| break; 1107| 4| } 1108| 420| if (p && p->right) ------------------ | Branch (1108:12): [True: 420, False: 0] | Branch (1108:17): [True: 322, False: 98] ------------------ 1109| 322| { 1110| 322| p = p->right; 1111| 322| break; 1112| 322| } 1113| 420| } 1114| 326| } 1115| 1.14k| } 1116| | 1117| 4| return ASN1_SUCCESS; ------------------ | | 116| 4|# define ASN1_SUCCESS 0 ------------------ 1118| 4|} parser_aux.c:_asn1_hash_name: 44| 1.43k|{ 45| 1.43k| const unsigned char *s = (unsigned char *) x; 46| 1.43k| unsigned h = 0; 47| | 48| 17.9k| while (*s) ------------------ | Branch (48:10): [True: 16.5k, False: 1.43k] ------------------ 49| 16.5k| h = (*s++) + ((h << 9) | (h >> (WORD_BIT - 9))); 50| | 51| 1.43k| return h; 52| 1.43k|} structure.c:_asn1_set_down: 112| 424|{ 113| 424| if (node == NULL) ------------------ | Branch (113:7): [True: 0, False: 424] ------------------ 114| 0| return node; 115| 424| node->down = down; 116| 424| if (down) ------------------ | Branch (116:7): [True: 424, False: 0] ------------------ 117| 424| down->left = node; 118| 424| return node; 119| 424|} asn1_array2tree: 179| 4|{ 180| 4| asn1_node p, p_last = NULL; 181| 4| unsigned long k; 182| 4| int move; 183| 4| int result; 184| 4| unsigned int type; 185| 4| list_type *e_list = NULL; 186| | 187| 4| if (errorDescription) ------------------ | Branch (187:7): [True: 0, False: 4] ------------------ 188| 0| errorDescription[0] = 0; 189| | 190| 4| if (*definitions != NULL) ------------------ | Branch (190:7): [True: 0, False: 4] ------------------ 191| 0| return ASN1_ELEMENT_NOT_EMPTY; ------------------ | | 133| 0|# define ASN1_ELEMENT_NOT_EMPTY 17 ------------------ 192| | 193| 4| move = UP; ------------------ | | 129| 4|# define UP 1 ------------------ 194| | 195| 1.14k| for (k = 0; array[k].value || array[k].type || array[k].name; k++) ------------------ | Branch (195:15): [True: 462, False: 684] | Branch (195:33): [True: 680, False: 4] | Branch (195:50): [True: 0, False: 4] ------------------ 196| 1.14k| { 197| 1.14k| type = convert_old_type (array[k].type); 198| | 199| 1.14k| p = _asn1_add_static_node (&e_list, type & (~CONST_DOWN)); ------------------ | | 168| 1.14k|# define CONST_DOWN (1U<<29) ------------------ 200| 1.14k| if (array[k].name) ------------------ | Branch (200:11): [True: 898, False: 244] ------------------ 201| 898| _asn1_set_name (p, array[k].name); 202| 1.14k| if (array[k].value) ------------------ | Branch (202:11): [True: 462, False: 680] ------------------ 203| 462| _asn1_set_value (p, array[k].value, strlen (array[k].value) + 1); 204| | 205| 1.14k| if (*definitions == NULL) ------------------ | Branch (205:11): [True: 4, False: 1.13k] ------------------ 206| 4| *definitions = p; 207| | 208| 1.14k| if (move == DOWN) ------------------ | | 131| 1.14k|# define DOWN 3 ------------------ | Branch (208:11): [True: 424, False: 718] ------------------ 209| 424| { 210| 424| if (p_last && p_last->down) ------------------ | Branch (210:8): [True: 424, False: 0] | Branch (210:18): [True: 0, False: 424] ------------------ 211| 0| _asn1_delete_structure (e_list, &p_last->down, 0); 212| 424| _asn1_set_down (p_last, p); 213| 424| } 214| 718| else if (move == RIGHT) ------------------ | | 130| 718|# define RIGHT 2 ------------------ | Branch (214:16): [True: 714, False: 4] ------------------ 215| 714| { 216| 714| if (p_last && p_last->right) ------------------ | Branch (216:8): [True: 714, False: 0] | Branch (216:18): [True: 0, False: 714] ------------------ 217| 0| _asn1_delete_structure (e_list, &p_last->right, 0); 218| 714| _asn1_set_right (p_last, p); 219| 714| } 220| | 221| 1.14k| p_last = p; 222| | 223| 1.14k| if (type & CONST_DOWN) ------------------ | | 168| 1.14k|# define CONST_DOWN (1U<<29) ------------------ | Branch (223:11): [True: 424, False: 718] ------------------ 224| 424| move = DOWN; ------------------ | | 131| 424|# define DOWN 3 ------------------ 225| 718| else if (type & CONST_RIGHT) ------------------ | | 169| 718|# define CONST_RIGHT (1U<<30) ------------------ | Branch (225:16): [True: 392, False: 326] ------------------ 226| 392| move = RIGHT; ------------------ | | 130| 392|# define RIGHT 2 ------------------ 227| 326| else 228| 326| { 229| 428| while (p_last != *definitions) ------------------ | Branch (229:11): [True: 424, False: 4] ------------------ 230| 424| { 231| 424| p_last = _asn1_find_up (p_last); 232| | 233| 424| if (p_last == NULL) ------------------ | Branch (233:12): [True: 0, False: 424] ------------------ 234| 0| break; 235| | 236| 424| if (p_last->type & CONST_RIGHT) ------------------ | | 169| 424|# define CONST_RIGHT (1U<<30) ------------------ | Branch (236:12): [True: 322, False: 102] ------------------ 237| 322| { 238| 322| p_last->type &= ~CONST_RIGHT; ------------------ | | 169| 322|# define CONST_RIGHT (1U<<30) ------------------ 239| 322| move = RIGHT; ------------------ | | 130| 322|# define RIGHT 2 ------------------ 240| 322| break; 241| 322| } 242| 424| } /* while */ 243| 326| } 244| 1.14k| } /* while */ 245| | 246| 4| if (p_last == *definitions) ------------------ | Branch (246:7): [True: 4, False: 0] ------------------ 247| 4| { 248| 4| result = _asn1_check_identifier (*definitions); 249| 4| if (result == ASN1_SUCCESS) ------------------ | | 116| 4|# define ASN1_SUCCESS 0 ------------------ | Branch (249:11): [True: 4, False: 0] ------------------ 250| 4| { 251| 4| _asn1_change_integer_value (*definitions); 252| 4| result = _asn1_expand_object_id (&e_list, *definitions); 253| 4| } 254| 4| } 255| 0| else 256| 0| { 257| 0| result = ASN1_ARRAY_ERROR; ------------------ | | 132| 0|# define ASN1_ARRAY_ERROR 16 ------------------ 258| 0| } 259| | 260| 4| if (errorDescription != NULL) ------------------ | Branch (260:7): [True: 0, False: 4] ------------------ 261| 0| { 262| 0| if (result == ASN1_IDENTIFIER_NOT_FOUND) ------------------ | | 119| 0|# define ASN1_IDENTIFIER_NOT_FOUND 3 ------------------ | Branch (262:11): [True: 0, False: 0] ------------------ 263| 0| { 264| 0| Estrcpy (errorDescription, ":: identifier '"); ------------------ | | 29| 0|# define Estrcpy(x,y) _asn1_str_cpy(x,ASN1_MAX_ERROR_DESCRIPTION_SIZE,y) | | ------------------ | | | | 315| 0|# define ASN1_MAX_ERROR_DESCRIPTION_SIZE 128 | | ------------------ ------------------ 265| 0| Estrcat (errorDescription, _asn1_identifierMissing); ------------------ | | 30| 0|# define Estrcat(x,y) _asn1_str_cat(x,ASN1_MAX_ERROR_DESCRIPTION_SIZE,y) | | ------------------ | | | | 315| 0|# define ASN1_MAX_ERROR_DESCRIPTION_SIZE 128 | | ------------------ ------------------ 266| 0| Estrcat (errorDescription, "' not found"); ------------------ | | 30| 0|# define Estrcat(x,y) _asn1_str_cat(x,ASN1_MAX_ERROR_DESCRIPTION_SIZE,y) | | ------------------ | | | | 315| 0|# define ASN1_MAX_ERROR_DESCRIPTION_SIZE 128 | | ------------------ ------------------ 267| 0| } 268| 0| else 269| 0| errorDescription[0] = 0; 270| 0| } 271| | 272| 4| if (result != ASN1_SUCCESS) ------------------ | | 116| 4|# define ASN1_SUCCESS 0 ------------------ | Branch (272:7): [True: 0, False: 4] ------------------ 273| 0| { 274| 0| _asn1_delete_list_and_nodes (e_list); 275| 0| *definitions = NULL; 276| 0| } 277| 4| else 278| 4| _asn1_delete_list (e_list); 279| | 280| 4| return result; 281| 4|} asn1_check_version: 46| 2|{ 47| 2| if (!req_version || strverscmp (req_version, ASN1_VERSION) <= 0) ------------------ | | 71| 2|# define ASN1_VERSION "4.19.0" ------------------ | Branch (47:7): [True: 0, False: 2] | Branch (47:23): [True: 2, False: 0] ------------------ 48| 2| return ASN1_VERSION; ------------------ | | 71| 2|# define ASN1_VERSION "4.19.0" ------------------ 49| | 50| 0| return NULL; 51| 2|} gnutls_crypto_init: 41| 2|{ 42| 2| void *(*defallocfunc)(size_t); 43| 2| void *(*defreallocfunc)(void *, size_t, size_t); 44| 2| void (*deffreefunc)(void *, size_t); 45| | 46| | /* Check if non-default allocators are being used. 47| | * Some applications like guile override GMP allocators 48| | * with GC capable alternatives. Do nothing if this is 49| | * the case. 50| | */ 51| 2| mp_get_memory_functions(&allocfunc, &reallocfunc, &freefunc); 52| 2| mp_set_memory_functions(NULL, NULL, NULL); 53| 2| mp_get_memory_functions(&defallocfunc, &defreallocfunc, &deffreefunc); 54| 2| if (reallocfunc != defreallocfunc || freefunc != deffreefunc) { ------------------ | Branch (54:6): [True: 0, False: 2] | Branch (54:39): [True: 0, False: 2] ------------------ 55| 0| mp_set_memory_functions(allocfunc, reallocfunc, freefunc); 56| 0| return (0); 57| 0| } 58| | 59| | /* Overload GMP allocators with safe alternatives */ 60| 2| mp_set_memory_functions(NULL, gnutls_realloc_zero, gnutls_free_zero); 61| 2| return 0; 62| 2|} _rnd_system_entropy_init: 161| 2|{ 162| 2| int urandom_fd; 163| | 164| 2|#if defined(__linux__) 165| | /* Enable getrandom() usage if available */ 166| 2| if (have_getrandom()) { ------------------ | Branch (166:6): [True: 2, False: 0] ------------------ 167| 2| _rnd_get_system_entropy = _rnd_get_system_entropy_getrandom; 168| 2| _gnutls_debug_log("getrandom random generator was selected\n"); ------------------ | | 139| 2|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 2|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 2|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 2] | | | | | | ------------------ | | | | ------------------ | | | | 137| 2| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 169| 2| return 0; 170| 2| } else { 171| 0| _gnutls_debug_log("getrandom is not available\n"); ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 172| 0| } 173| 0|#endif 174| | 175| | /* Fallback: /dev/urandom */ 176| | 177| | /* Check that we can open it */ 178| 0| urandom_fd = open("/dev/urandom", O_RDONLY); 179| 0| if (urandom_fd < 0) { ------------------ | Branch (179:6): [True: 0, False: 0] ------------------ 180| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 181| 0| ("Cannot open /dev/urandom during initialization!\n"); 182| 0| return gnutls_assert_val(GNUTLS_E_RANDOM_DEVICE_ERROR); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 183| 0| } 184| 0| close(urandom_fd); 185| | 186| 0| _rnd_get_system_entropy = _rnd_get_system_entropy_urandom; 187| 0| _gnutls_debug_log("/dev/urandom random generator was selected\n"); ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 188| | 189| 0| return 0; 190| 0|} sysrng-linux.c:have_getrandom: 71| 2|{ 72| 2| char c; 73| 2| int ret; 74| 2| ret = getrandom(&c, 1, 1 /*GRND_NONBLOCK */ ); 75| 2| if (ret == 1 || (ret == -1 && errno == EAGAIN)) ------------------ | Branch (75:6): [True: 2, False: 0] | Branch (75:19): [True: 0, False: 0] | Branch (75:32): [True: 0, False: 0] ------------------ 76| 2| return 1; 77| 0| return 0; 78| 2|} _gnutls_prepare_to_load_system_priorities: 2425| 2|{ 2426| 2| const char *p; 2427| 2| int ret; 2428| | 2429| 2| p = secure_getenv("GNUTLS_SYSTEM_PRIORITY_FILE"); 2430| 2| if (p != NULL) ------------------ | Branch (2430:6): [True: 0, False: 2] ------------------ 2431| 0| system_priority_file = p; 2432| | 2433| 2| p = secure_getenv("GNUTLS_SYSTEM_PRIORITY_FAIL_ON_INVALID"); 2434| 2| if (p != NULL && p[0] == '1' && p[1] == 0) ------------------ | Branch (2434:6): [True: 0, False: 2] | Branch (2434:19): [True: 0, False: 0] | Branch (2434:34): [True: 0, False: 0] ------------------ 2435| 0| fail_on_invalid_config = 1; 2436| | 2437| 2| ret = _gnutls_update_system_priorities(true /* defer_system_wide */ ); 2438| 2| if (ret < 0) { ------------------ | Branch (2438:6): [True: 0, False: 2] ------------------ 2439| 0| _gnutls_debug_log("failed to update system priorities: %s\n", ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2440| 0| gnutls_strerror(ret)); 2441| 0| } 2442| 2|} priority.c:_gnutls_update_system_priorities: 2302| 2|{ 2303| 2| int ret, err = 0; 2304| 2| struct stat sb; 2305| 2| FILE *fp; 2306| 2| gnutls_buffer_st buf; 2307| 2| struct ini_ctx ctx; 2308| | 2309| 2| ret = gnutls_rwlock_rdlock(&system_wide_config_rwlock); ------------------ | | 60| 2| (unlikely(glthread_rwlock_rdlock(RWLOCK)) ? \ | | ------------------ | | | | 73| 6|# define unlikely(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (73:26): [True: 0, False: 2] | | | | | Branch (73:44): [True: 2, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 61| 2| gnutls_assert_val(GNUTLS_E_LOCKING_ERROR) : 0) | | ------------------ | | | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) | | ------------------ ------------------ 2310| 2| if (ret < 0) { ------------------ | Branch (2310:6): [True: 0, False: 2] ------------------ 2311| 0| return gnutls_assert_val(ret); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 2312| 0| } 2313| | 2314| 2| if (stat(system_priority_file, &sb) < 0) { ------------------ | Branch (2314:6): [True: 2, False: 0] ------------------ 2315| 2| _gnutls_debug_log("cfg: unable to access: %s: %d\n", ------------------ | | 139| 2|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 2|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 2|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 2] | | | | | | ------------------ | | | | ------------------ | | | | 137| 2| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2316| 2| system_priority_file, errno); 2317| 2| goto out; 2318| 2| } 2319| | 2320| 0| if (system_priority_file_loaded && ------------------ | Branch (2320:6): [True: 0, False: 0] ------------------ 2321| 0| system_priority_last_mod == sb.st_mtime) { ------------------ | Branch (2321:6): [True: 0, False: 0] ------------------ 2322| 0| _gnutls_debug_log("cfg: system priority %s has not changed\n", ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2323| 0| system_priority_file); 2324| 0| if (system_wide_config.priority_string) { ------------------ | Branch (2324:7): [True: 0, False: 0] ------------------ 2325| 0| goto out; /* nothing to do */ 2326| 0| } 2327| 0| } 2328| | 2329| 0| (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); ------------------ | | 68| 0| (unlikely(glthread_rwlock_unlock(RWLOCK)) ? \ | | ------------------ | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (73:26): [True: 0, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 69| 0| gnutls_assert_val(GNUTLS_E_LOCKING_ERROR) : 0) | | ------------------ | | | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) | | ------------------ ------------------ 2330| | 2331| 0| ret = gnutls_rwlock_wrlock(&system_wide_config_rwlock); ------------------ | | 64| 0| (unlikely(glthread_rwlock_wrlock(RWLOCK)) ? \ | | ------------------ | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (73:26): [True: 0, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 65| 0| gnutls_assert_val(GNUTLS_E_LOCKING_ERROR) : 0) | | ------------------ | | | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) | | ------------------ ------------------ 2332| 0| if (ret < 0) { ------------------ | Branch (2332:6): [True: 0, False: 0] ------------------ 2333| 0| return gnutls_assert_val(ret); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 2334| 0| } 2335| | 2336| | /* Another thread could have successfully re-read system-wide config, 2337| | * skip re-reading if the mtime it has used is exactly the same. 2338| | */ 2339| 0| if (system_priority_file_loaded) { ------------------ | Branch (2339:6): [True: 0, False: 0] ------------------ 2340| 0| system_priority_file_loaded = 2341| 0| (system_priority_last_mod == sb.st_mtime); 2342| 0| } 2343| | 2344| 0| if (!system_priority_file_loaded) { ------------------ | Branch (2344:6): [True: 0, False: 0] ------------------ 2345| 0| _name_val_array_clear(&system_wide_config.priority_strings); 2346| | 2347| 0| gnutls_free(system_wide_config.priority_string); ------------------ | | 2296| 0|# define gnutls_free(a) gnutls_free((void *) (a)), a=NULL ------------------ 2348| 0| system_wide_config.priority_string = NULL; 2349| | 2350| 0| fp = fopen(system_priority_file, "re"); 2351| 0| if (fp == NULL) { ------------------ | Branch (2351:7): [True: 0, False: 0] ------------------ 2352| 0| _gnutls_debug_log("cfg: unable to open: %s: %d\n", ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2353| 0| system_priority_file, errno); 2354| 0| goto out; 2355| 0| } 2356| | /* Parsing the configuration file needs to be done in 2 phases: 2357| | * first parsing the [global] section 2358| | * and then the other sections, 2359| | * because the [global] section modifies the parsing behavior. 2360| | */ 2361| 0| memset(&ctx, 0, sizeof(ctx)); 2362| 0| err = ini_parse_file(fp, global_ini_handler, &ctx); 2363| 0| if (!err) { ------------------ | Branch (2363:7): [True: 0, False: 0] ------------------ 2364| 0| if (fseek(fp, 0L, SEEK_SET) < 0) { ------------------ | Branch (2364:8): [True: 0, False: 0] ------------------ 2365| 0| _gnutls_debug_log("cfg: unable to rewind: %s\n", ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2366| 0| system_priority_file); 2367| 0| if (fail_on_invalid_config) ------------------ | Branch (2367:9): [True: 0, False: 0] ------------------ 2368| 0| exit(1); 2369| 0| } 2370| 0| err = ini_parse_file(fp, cfg_ini_handler, &ctx); 2371| 0| } 2372| 0| fclose(fp); 2373| 0| if (err) { ------------------ | Branch (2373:7): [True: 0, False: 0] ------------------ 2374| 0| ini_ctx_deinit(&ctx); 2375| 0| _gnutls_debug_log("cfg: unable to parse: %s: %d\n", ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2376| 0| system_priority_file, err); 2377| 0| goto out; 2378| 0| } 2379| 0| cfg_apply(&system_wide_config, &ctx); 2380| 0| ini_ctx_deinit(&ctx); 2381| 0| _gnutls_debug_log("cfg: loaded system config %s mtime %lld\n", ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2382| 0| system_priority_file, 2383| 0| (unsigned long long)sb.st_mtime); 2384| | 2385| 0| } 2386| | 2387| 0| if (system_wide_config.allowlisting) { ------------------ | Branch (2387:6): [True: 0, False: 0] ------------------ 2388| 0| if (defer_system_wide) { ------------------ | Branch (2388:7): [True: 0, False: 0] ------------------ 2389| | /* try constructing a priority string, 2390| | * but don't apply it yet, at this point 2391| | * we're only interested in whether we can */ 2392| 0| ret = construct_system_wide_priority_string(&buf); 2393| 0| _gnutls_buffer_clear(&buf); 2394| 0| _gnutls_debug_log("cfg: deferred setting " ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2395| 0| "system-wide priority string\n"); 2396| 0| } else { 2397| 0| ret = update_system_wide_priority_string(); 2398| 0| _gnutls_debug_log("cfg: finalized " ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2399| 0| "system-wide priority string\n"); 2400| 0| } 2401| 0| if (ret < 0) { ------------------ | Branch (2401:7): [True: 0, False: 0] ------------------ 2402| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2403| 0| ("cfg: unable to build priority string: %s\n", 2404| 0| gnutls_strerror(ret)); 2405| 0| if (fail_on_invalid_config) ------------------ | Branch (2405:8): [True: 0, False: 0] ------------------ 2406| 0| exit(1); 2407| 0| goto out; 2408| 0| } 2409| 0| } 2410| | 2411| 0| system_priority_file_loaded = 1; 2412| 0| system_priority_last_mod = sb.st_mtime; 2413| | 2414| 2| out: 2415| 2| (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); ------------------ | | 68| 2| (unlikely(glthread_rwlock_unlock(RWLOCK)) ? \ | | ------------------ | | | | 73| 6|# define unlikely(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (73:26): [True: 0, False: 2] | | | | | Branch (73:44): [True: 2, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 69| 2| gnutls_assert_val(GNUTLS_E_LOCKING_ERROR) : 0) | | ------------------ | | | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) | | ------------------ ------------------ 2416| | 2417| 2| if (err && fail_on_invalid_config) { ------------------ | Branch (2417:6): [True: 0, False: 2] | Branch (2417:13): [True: 0, False: 0] ------------------ 2418| 0| exit(1); 2419| 0| } 2420| | 2421| 2| return ret; 2422| 2|} _gnutls_rnd_preinit: 106| 2|{ 107| 2| int ret; 108| | 109| |#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) 110| |# warning Insecure PRNG is enabled 111| | ret = gnutls_crypto_rnd_register(100, &_gnutls_fuzz_rnd_ops); 112| | if (ret < 0) 113| | return ret; 114| | 115| |#elif defined(ENABLE_FIPS140) 116| | /* The FIPS140 random generator is only enabled when we are compiled 117| | * with FIPS support, _and_ the system is in FIPS installed state. 118| | */ 119| | if (_gnutls_fips_mode_enabled()) { 120| | ret = gnutls_crypto_rnd_register(100, &_gnutls_fips_rnd_ops); 121| | if (ret < 0) 122| | return ret; 123| | } 124| |#endif 125| | 126| 2| ret = _rnd_system_entropy_init(); 127| 2| if (ret < 0) ------------------ | Branch (127:6): [True: 0, False: 2] ------------------ 128| 0| return gnutls_assert_val(GNUTLS_E_RANDOM_FAILED); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 129| | 130| 2| ret = glthread_tls_key_init(&ctx_key, delete_ctx); ------------------ | | 135| 2| (pthread_in_use () \ | | ------------------ | | | | 115| 2| (pthread_mutexattr_gettype != NULL || c11_threads_in_use ()) | | | | ------------------ | | | | | | 89| 0|# define c11_threads_in_use() (thrd_exit != NULL) | | | | | | ------------------ | | | | | | | Branch (89:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (115:8): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 136| 2| ? pthread_key_create (&(KEY)->key, DESTRUCTOR) \ | | 137| 2| : ((KEY)->singlethread_value = NULL, 0)) ------------------ 131| 2| if (ret) ------------------ | Branch (131:6): [True: 0, False: 2] ------------------ 132| 0| return gnutls_assert_val(GNUTLS_E_RANDOM_FAILED); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 133| | 134| 2| list = 135| 2| gl_list_nx_create_empty(GL_LINKEDHASH_LIST, NULL, NULL, free_ctx, ------------------ | | 28| 2|#define GL_LINKEDHASH_LIST &gl_linkedhash_list_implementation ------------------ 136| 2| false); 137| 2| if (list == NULL) ------------------ | Branch (137:6): [True: 0, False: 2] ------------------ 138| 0| return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 139| | 140| 2| return 0; 141| 2|} gnutls_system_global_init: 69| 2|{ 70| |#if defined(_WIN32) && defined(NEED_CERT_ENUM_CRLS) 71| | /* used in system/certs.c */ 72| | HMODULE crypto; 73| | crypto = LoadLibrary(TEXT("Crypt32.dll")); 74| | 75| | if (crypto == NULL) 76| | return GNUTLS_E_CRYPTO_INIT_FAILED; 77| | 78| | pCertEnumCRLsInStore = 79| | (CertEnumCRLsInStoreFunc) GetProcAddress(crypto, 80| | "CertEnumCRLsInStore"); 81| | if (pCertEnumCRLsInStore == NULL) { 82| | FreeLibrary(crypto); 83| | return GNUTLS_E_CRYPTO_INIT_FAILED; 84| | } 85| | 86| | Crypt32_dll = crypto; 87| |#endif 88| 2| gnutls_time = time; 89| 2| gnutls_gettime = _gnutls_gettime; 90| 2| return 0; 91| 2|} _gnutls_system_key_init: 70| 2|{ 71| 2| return 0; 72| 2|} fat-x86_64.c:fat_init: 177| 2|{ 178| 2| struct x86_features features; 179| 2| int verbose; 180| | 181| | /* FIXME: Replace all getenv calls by getenv_secure? */ 182| 2| verbose = getenv (ENV_VERBOSE) != NULL; ------------------ | | 93| 2|#define ENV_VERBOSE "NETTLE_FAT_VERBOSE" ------------------ 183| 2| if (verbose) ------------------ | Branch (183:7): [True: 0, False: 2] ------------------ 184| 0| fprintf (stderr, "libnettle: fat library initialization.\n"); 185| | 186| 2| get_x86_features (&features); 187| 2| if (verbose) ------------------ | Branch (187:7): [True: 0, False: 2] ------------------ 188| 0| { 189| 0| const char * const vendor_names[3] = 190| 0| { "other", "intel", "amd" }; 191| 0| fprintf (stderr, "libnettle: cpu features: vendor:%s%s%s%s\n", 192| 0| vendor_names[features.vendor], 193| 0| features.have_aesni ? ",aesni" : "", ------------------ | Branch (193:9): [True: 0, False: 0] ------------------ 194| 0| features.have_sha_ni ? ",sha_ni" : "", ------------------ | Branch (194:9): [True: 0, False: 0] ------------------ 195| 0| features.have_pclmul ? ",pclmul" : ""); ------------------ | Branch (195:9): [True: 0, False: 0] ------------------ 196| 0| } 197| 2| if (features.have_aesni) ------------------ | Branch (197:7): [True: 2, False: 0] ------------------ 198| 2| { 199| 2| if (verbose) ------------------ | Branch (199:11): [True: 0, False: 2] ------------------ 200| 0| fprintf (stderr, "libnettle: using aes instructions.\n"); 201| 2| nettle_aes128_encrypt_vec = _nettle_aes128_encrypt_aesni; 202| 2| nettle_aes128_decrypt_vec = _nettle_aes128_decrypt_aesni; 203| 2| nettle_aes192_encrypt_vec = _nettle_aes192_encrypt_aesni; 204| 2| nettle_aes192_decrypt_vec = _nettle_aes192_decrypt_aesni; 205| 2| nettle_aes256_encrypt_vec = _nettle_aes256_encrypt_aesni; 206| 2| nettle_aes256_decrypt_vec = _nettle_aes256_decrypt_aesni; 207| 2| nettle_cbc_aes128_encrypt_vec = _nettle_cbc_aes128_encrypt_aesni; 208| 2| nettle_cbc_aes192_encrypt_vec = _nettle_cbc_aes192_encrypt_aesni; 209| 2| nettle_cbc_aes256_encrypt_vec = _nettle_cbc_aes256_encrypt_aesni; 210| 2| } 211| 0| else 212| 0| { 213| 0| if (verbose) ------------------ | Branch (213:11): [True: 0, False: 0] ------------------ 214| 0| fprintf (stderr, "libnettle: not using aes instructions.\n"); 215| 0| nettle_aes128_encrypt_vec = _nettle_aes128_encrypt_c; 216| 0| nettle_aes128_decrypt_vec = _nettle_aes128_decrypt_c; 217| 0| nettle_aes192_encrypt_vec = _nettle_aes192_encrypt_c; 218| 0| nettle_aes192_decrypt_vec = _nettle_aes192_decrypt_c; 219| 0| nettle_aes256_encrypt_vec = _nettle_aes256_encrypt_c; 220| 0| nettle_aes256_decrypt_vec = _nettle_aes256_decrypt_c; 221| 0| nettle_cbc_aes128_encrypt_vec = _nettle_cbc_aes128_encrypt_c; 222| 0| nettle_cbc_aes192_encrypt_vec = _nettle_cbc_aes192_encrypt_c; 223| 0| nettle_cbc_aes256_encrypt_vec = _nettle_cbc_aes256_encrypt_c; 224| 0| } 225| | 226| 2| if (features.have_sha_ni) ------------------ | Branch (226:7): [True: 2, False: 0] ------------------ 227| 2| { 228| 2| if (verbose) ------------------ | Branch (228:11): [True: 0, False: 2] ------------------ 229| 0| fprintf (stderr, "libnettle: using sha_ni instructions.\n"); 230| 2| nettle_sha1_compress_vec = _nettle_sha1_compress_sha_ni; 231| 2| _nettle_sha256_compress_n_vec = _nettle_sha256_compress_n_sha_ni; 232| 2| } 233| 0| else 234| 0| { 235| 0| if (verbose) ------------------ | Branch (235:11): [True: 0, False: 0] ------------------ 236| 0| fprintf (stderr, "libnettle: not using sha_ni instructions.\n"); 237| 0| nettle_sha1_compress_vec = _nettle_sha1_compress_x86_64; 238| 0| _nettle_sha256_compress_n_vec = _nettle_sha256_compress_n_x86_64; 239| 0| } 240| | 241| 2| if (features.have_pclmul) ------------------ | Branch (241:7): [True: 2, False: 0] ------------------ 242| 2| { 243| 2| if (verbose) ------------------ | Branch (243:11): [True: 0, False: 2] ------------------ 244| 0| fprintf (stderr, "libnettle: using pclmulqdq instructions.\n"); 245| 2| _nettle_ghash_set_key_vec = _nettle_ghash_set_key_pclmul; 246| 2| _nettle_ghash_update_vec = _nettle_ghash_update_pclmul; 247| 2| } 248| 0| else 249| 0| { 250| 0| if (verbose) ------------------ | Branch (250:11): [True: 0, False: 0] ------------------ 251| 0| fprintf (stderr, "libnettle: not using pclmulqdq instructions.\n"); 252| 0| _nettle_ghash_set_key_vec = _nettle_ghash_set_key_c; 253| 0| _nettle_ghash_update_vec = _nettle_ghash_update_table; 254| 0| } 255| | 256| 2| if (features.vendor == X86_INTEL) ------------------ | Branch (256:7): [True: 0, False: 2] ------------------ 257| 0| { 258| 0| if (verbose) ------------------ | Branch (258:11): [True: 0, False: 0] ------------------ 259| 0| fprintf (stderr, "libnettle: intel SSE2 will be used for memxor.\n"); 260| 0| nettle_memxor_vec = _nettle_memxor_sse2; 261| 0| } 262| 2| else 263| 2| { 264| 2| if (verbose) ------------------ | Branch (264:11): [True: 0, False: 2] ------------------ 265| 0| fprintf (stderr, "libnettle: intel SSE2 will not be used for memxor.\n"); 266| 2| nettle_memxor_vec = _nettle_memxor_x86_64; 267| 2| } 268| 2|} fat-x86_64.c:get_x86_features: 68| 2|{ 69| 2| const char *s; 70| 2| features->vendor = X86_OTHER; 71| 2| features->have_aesni = 0; 72| 2| features->have_sha_ni = 0; 73| 2| features->have_pclmul = 0; 74| | 75| 2| s = secure_getenv (ENV_OVERRIDE); ------------------ | | 94| 2|#define ENV_OVERRIDE "NETTLE_FAT_OVERRIDE" ------------------ 76| 2| if (s) ------------------ | Branch (76:7): [True: 0, False: 2] ------------------ 77| 0| for (;;) 78| 0| { 79| 0| const char *sep = strchr (s, ','); 80| 0| size_t length = sep ? (size_t) (sep - s) : strlen(s); ------------------ | Branch (80:18): [True: 0, False: 0] ------------------ 81| | 82| 0| if (SKIP (s, length, "vendor:", 7)) ------------------ | | 61| 0| (((slen) >= (llen) && memcmp ((s), (literal), llen) == 0) \ | | ------------------ | | | Branch (61:3): [True: 0, False: 0] | | | Branch (61:5): [True: 0, False: 0] | | | Branch (61:25): [True: 0, False: 0] | | ------------------ | | 62| 0| ? ((slen) -= (llen), (s) += (llen), 1) : 0) ------------------ 83| 0| { 84| 0| if (MATCH(s, length, "intel", 5)) ------------------ | | 64| 0| ((slen) == (llen) && memcmp ((s), (literal), llen) == 0) | | ------------------ | | | Branch (64:4): [True: 0, False: 0] | | | Branch (64:24): [True: 0, False: 0] | | ------------------ ------------------ 85| 0| features->vendor = X86_INTEL; 86| 0| else if (MATCH(s, length, "amd", 3)) ------------------ | | 64| 0| ((slen) == (llen) && memcmp ((s), (literal), llen) == 0) | | ------------------ | | | Branch (64:4): [True: 0, False: 0] | | | Branch (64:24): [True: 0, False: 0] | | ------------------ ------------------ 87| 0| features->vendor = X86_AMD; 88| | 89| 0| } 90| 0| else if (MATCH (s, length, "aesni", 5)) ------------------ | | 64| 0| ((slen) == (llen) && memcmp ((s), (literal), llen) == 0) | | ------------------ | | | Branch (64:4): [True: 0, False: 0] | | | Branch (64:24): [True: 0, False: 0] | | ------------------ ------------------ 91| 0| features->have_aesni = 1; 92| 0| else if (MATCH (s, length, "sha_ni", 6)) ------------------ | | 64| 0| ((slen) == (llen) && memcmp ((s), (literal), llen) == 0) | | ------------------ | | | Branch (64:4): [True: 0, False: 0] | | | Branch (64:24): [True: 0, False: 0] | | ------------------ ------------------ 93| 0| features->have_sha_ni = 1; 94| 0| else if (MATCH (s, length, "pclmul", 6)) ------------------ | | 64| 0| ((slen) == (llen) && memcmp ((s), (literal), llen) == 0) | | ------------------ | | | Branch (64:4): [True: 0, False: 0] | | | Branch (64:24): [True: 0, False: 0] | | ------------------ ------------------ 95| 0| features->have_pclmul = 1; 96| 0| if (!sep) ------------------ | Branch (96:6): [True: 0, False: 0] ------------------ 97| 0| break; 98| 0| s = sep + 1; 99| 0| } 100| 2| else 101| 2| { 102| 2| uint32_t cpuid_data[4]; 103| 2| _nettle_cpuid (0, cpuid_data); 104| 2| if (memcmp (cpuid_data + 1, "Genu" "ntel" "ineI", 12) == 0) ------------------ | Branch (104:11): [True: 0, False: 2] ------------------ 105| 0| features->vendor = X86_INTEL; 106| 2| else if (memcmp (cpuid_data + 1, "Auth" "cAMD" "enti", 12) == 0) ------------------ | Branch (106:16): [True: 2, False: 0] ------------------ 107| 2| features->vendor = X86_AMD; 108| | 109| 2| _nettle_cpuid (1, cpuid_data); 110| 2| if (cpuid_data[2] & 0x2) ------------------ | Branch (110:11): [True: 2, False: 0] ------------------ 111| 2| features->have_pclmul = 1; 112| 2| if (cpuid_data[2] & 0x02000000) ------------------ | Branch (112:11): [True: 2, False: 0] ------------------ 113| 2| features->have_aesni = 1; 114| | 115| 2| _nettle_cpuid (7, cpuid_data); 116| 2| if (cpuid_data[1] & 0x20000000) ------------------ | Branch (116:11): [True: 2, False: 0] ------------------ 117| 2| features->have_sha_ni = 1; 118| 2| } 119| 2|} mp_get_memory_functions: 326| 4|{ 327| 4| if (alloc_func) ------------------ | Branch (327:7): [True: 4, False: 0] ------------------ 328| 4| *alloc_func = gmp_allocate_func; 329| | 330| 4| if (realloc_func) ------------------ | Branch (330:7): [True: 4, False: 0] ------------------ 331| 4| *realloc_func = gmp_reallocate_func; 332| | 333| 4| if (free_func) ------------------ | Branch (333:7): [True: 4, False: 0] ------------------ 334| 4| *free_func = gmp_free_func; 335| 4|} mp_set_memory_functions: 341| 4|{ 342| 4| if (!alloc_func) ------------------ | Branch (342:7): [True: 4, False: 0] ------------------ 343| 4| alloc_func = gmp_default_alloc; 344| 4| if (!realloc_func) ------------------ | Branch (344:7): [True: 2, False: 2] ------------------ 345| 2| realloc_func = gmp_default_realloc; 346| 4| if (!free_func) ------------------ | Branch (346:7): [True: 2, False: 2] ------------------ 347| 2| free_func = gmp_default_free; 348| | 349| 4| gmp_allocate_func = alloc_func; 350| 4| gmp_reallocate_func = realloc_func; 351| 4| gmp_free_func = free_func; 352| 4|} LLVMFuzzerTestOneInput: 76| 933|{ 77| 933| void *progress; 78| | 79| 933| if (size > 4096) // same as max_len = ... in .options file ------------------ | Branch (79:6): [True: 9, False: 924] ------------------ 80| 9| return 0; 81| | 82| 924| if (size < NAMEPOS) ------------------ | | 74| 924|#define NAMEPOS (2 * sizeof(wgint) + sizeof(double)) ------------------ | Branch (82:6): [True: 9, False: 915] ------------------ 83| 9| return 0; 84| | 85| |// CLOSE_STDERR 86| | 87| 915| wgint start = ((wgint *) data)[0]; 88| 915| wgint end = ((wgint *) data)[1]; 89| 915| double dltime = ((wgint *) data)[2]; 90| | 91| 915| if (start < 0 || end < 0) ------------------ | Branch (91:6): [True: 66, False: 849] | Branch (91:19): [True: 63, False: 786] ------------------ 92| 129| return 0; 93| | 94| 786| if (start > end) { ------------------ | Branch (94:6): [True: 410, False: 376] ------------------ 95| 410| wgint x = start; 96| 410| start = end; 97| 410| end = x; 98| 410| } 99| | 100| |// double dltime = ((double *) (data + 2 * sizeof(wgint)))[0]; 101| | 102| 786| char *filename = strndup((char *) (data + NAMEPOS), size - NAMEPOS); ------------------ | | 74| 786|#define NAMEPOS (2 * sizeof(wgint) + sizeof(double)) ------------------ char *filename = strndup((char *) (data + NAMEPOS), size - NAMEPOS); ------------------ | | 74| 786|#define NAMEPOS (2 * sizeof(wgint) + sizeof(double)) ------------------ 103| | 104| |// printf("%ld %ld %lf %s\n", start, end, dltime, filename); 105| | 106| 786| set_progress_implementation("bar:force"); // [:force][:noscroll] 107| | 108| 786| progress = progress_create (filename, start, end); 109| 786| progress_update (progress, 0, dltime); 110| 786| progress_update (progress, end - start, dltime); 111| 786| progress_finish (progress, dltime); 112| | 113| 786| set_progress_implementation("dot:default");// [:default|:binary|:mega|:giga] 114| 786| progress = progress_create (filename, start, end); 115| 786| progress_update (progress, 0, dltime); 116| 786| progress_update (progress, end - start, dltime); 117| 786| progress_finish (progress, dltime); 118| | 119| 786| set_progress_implementation("dot:binary");// [:default|:binary|:mega|:giga] 120| 786| progress = progress_create (filename, start, end); 121| 786| progress_update (progress, 0, dltime); 122| 786| progress_update (progress, end - start, dltime); 123| 786| progress_finish (progress, dltime); 124| | 125| 786| set_progress_implementation("dot:mega");// [:default|:binary|:mega|:giga] 126| 786| progress = progress_create (filename, start, end); 127| 786| progress_update (progress, 0, dltime); 128| 786| progress_update (progress, end - start, dltime); 129| 786| progress_finish (progress, dltime); 130| | 131| 786| set_progress_implementation("dot:giga");// [:default|:binary|:mega|:giga] 132| 786| progress = progress_create (filename, start, end); 133| 786| progress_update (progress, 0, dltime); 134| 786| progress_update (progress, end - start, dltime); 135| 786| progress_finish (progress, dltime); 136| | 137| 786| free(filename); 138| | 139| |// RESTORE_STDERR 140| | 141| 786| return 0; 142| 915|} c_strcasecmp: 28| 7.86k|{ 29| 7.86k| register const unsigned char *p1 = (const unsigned char *) s1; 30| 7.86k| register const unsigned char *p2 = (const unsigned char *) s2; 31| 7.86k| unsigned char c1, c2; 32| | 33| 7.86k| if (p1 == p2) ------------------ | Branch (33:7): [True: 3.14k, False: 4.71k] ------------------ 34| 3.14k| return 0; 35| | 36| 4.71k| do 37| 4.71k| { 38| 4.71k| c1 = c_tolower (*p1); 39| 4.71k| c2 = c_tolower (*p2); 40| | 41| 4.71k| if (c1 == '\0') ------------------ | Branch (41:11): [True: 0, False: 4.71k] ------------------ 42| 0| break; 43| | 44| 4.71k| ++p1; 45| 4.71k| ++p2; 46| 4.71k| } 47| 4.71k| while (c1 == c2); ------------------ | Branch (47:10): [True: 0, False: 4.71k] ------------------ 48| | 49| 4.71k| if (UCHAR_MAX <= INT_MAX) ------------------ | Branch (49:7): [Folded - Ignored] ------------------ 50| 4.71k| return c1 - c2; 51| 0| else 52| | /* On machines where 'char' and 'int' are types of the same size, the 53| | difference of two 'unsigned char' values - including the sign bit - 54| | doesn't fit in an 'int'. */ 55| 0| return _GL_CMP (c1, c2); ------------------ | | 3058| 0|#define _GL_CMP(n1, n2) (((n1) > (n2)) - ((n1) < (n2))) ------------------ 56| 4.71k|} rpl_free: 33| 7.43k|{ 34| |# if defined __GNUC__ && !defined __clang__ 35| | /* An invalid GCC optimization 36| | 37| | would optimize away the assignments in the code below, when link-time 38| | optimization (LTO) is enabled. Make the code more complicated, so that 39| | GCC does not grok how to optimize it. */ 40| | int err[2]; 41| | err[0] = errno; 42| | err[1] = errno; 43| | errno = 0; 44| | free (p); 45| | errno = err[errno == 0]; 46| |# else 47| 7.43k| int err = errno; 48| 7.43k| free (p); 49| 7.43k| errno = err; 50| 7.43k|# endif 51| 7.43k|} hard_locale: 29| 42.1k|{ 30| 42.1k| char locale[SETLOCALE_NULL_MAX]; 31| | 32| 42.1k| if (setlocale_null_r (category, locale, sizeof (locale))) ------------------ | Branch (32:7): [True: 0, False: 42.1k] ------------------ 33| 0| return false; 34| | 35| 42.1k| if (!(strcmp (locale, "C") == 0 || strcmp (locale, "POSIX") == 0)) ------------------ | Branch (35:9): [True: 42.1k, False: 0] | Branch (35:38): [True: 0, False: 0] ------------------ 36| 0| return true; 37| | 38| |#if defined __ANDROID__ 39| | /* On Android 5.0 or newer, it is possible to set a locale that has the same 40| | name as the "C" locale but in fact uses UTF-8 encoding. Cf. test case 2 in 41| | . */ 42| | if (MB_CUR_MAX > 1) 43| | return true; 44| |#endif 45| | 46| 42.1k| return false; 47| 42.1k|} rpl_ioctl: 32| 1|{ 33| 1| void *buf; 34| 1| va_list args; 35| | 36| 1| va_start (args, request); 37| 1| buf = va_arg (args, void *); 38| 1| va_end (args); 39| | 40| | /* Cast 'request' so that when the system's ioctl function takes a 64-bit 41| | request argument, the value gets zero-extended, not sign-extended. */ 42| 1| return ioctl (fd, (unsigned int) request, buf); 43| 1|} rpl_mbrtowc: 79| 46.5k|{ 80| 46.5k| size_t ret; 81| 46.5k| wchar_t wc; 82| | 83| |# if MBRTOWC_NULL_ARG2_BUG || MBRTOWC_RETVAL_BUG || MBRTOWC_EMPTY_INPUT_BUG 84| | if (s == NULL) 85| | { 86| | pwc = NULL; 87| | s = ""; 88| | n = 1; 89| | } 90| |# endif 91| | 92| |# if MBRTOWC_EMPTY_INPUT_BUG 93| | if (n == 0) 94| | return (size_t) -2; 95| |# endif 96| | 97| 46.5k| if (! pwc) ------------------ | Branch (97:7): [True: 0, False: 46.5k] ------------------ 98| 0| pwc = &wc; 99| | 100| |# if MBRTOWC_RETVAL_BUG 101| | { 102| | static mbstate_t internal_state; 103| | 104| | /* Override mbrtowc's internal state. We cannot call mbsinit() on the 105| | hidden internal state, but we can call it on our variable. */ 106| | if (ps == NULL) 107| | ps = &internal_state; 108| | 109| | if (!mbsinit (ps)) 110| | { 111| | /* Parse the rest of the multibyte character byte for byte. */ 112| | size_t count = 0; 113| | for (; n > 0; s++, n--) 114| | { 115| | ret = mbrtowc (&wc, s, 1, ps); 116| | 117| | if (ret == (size_t)(-1)) 118| | return (size_t)(-1); 119| | count++; 120| | if (ret != (size_t)(-2)) 121| | { 122| | /* The multibyte character has been completed. */ 123| | *pwc = wc; 124| | return (wc == 0 ? 0 : count); 125| | } 126| | } 127| | return (size_t)(-2); 128| | } 129| | } 130| |# endif 131| | 132| |# if MBRTOWC_STORES_INCOMPLETE_BUG 133| | ret = mbrtowc (&wc, s, n, ps); 134| | if (ret < (size_t) -2 && pwc != NULL) 135| | *pwc = wc; 136| |# else 137| 46.5k| ret = mbrtowc (pwc, s, n, ps); 138| 46.5k|# endif 139| | 140| |# if MBRTOWC_NUL_RETVAL_BUG 141| | if (ret < (size_t) -2 && !*pwc) 142| | return 0; 143| |# endif 144| | 145| 46.5k|# if MBRTOWC_IN_C_LOCALE_MAYBE_EILSEQ 146| 46.5k| if ((size_t) -2 <= ret && n != 0 && ! hard_locale (LC_CTYPE)) ------------------ | Branch (146:7): [True: 42.1k, False: 4.40k] | Branch (146:29): [True: 42.1k, False: 0] | Branch (146:39): [True: 42.1k, False: 0] ------------------ 147| 42.1k| { 148| 42.1k| unsigned char uc = *s; 149| 42.1k| *pwc = uc; 150| 42.1k| return 1; 151| 42.1k| } 152| 4.40k|# endif 153| | 154| 4.40k| return ret; 155| 46.5k|} setlocale_null_r: 270| 42.1k|{ 271| 42.1k|#if SETLOCALE_NULL_ALL_MTSAFE 272| 42.1k|# if SETLOCALE_NULL_ONE_MTSAFE 273| | 274| 42.1k| return setlocale_null_unlocked (category, buf, bufsize); 275| | 276| |# else 277| | 278| | if (category == LC_ALL) 279| | return setlocale_null_unlocked (category, buf, bufsize); 280| | else 281| | return setlocale_null_with_lock (category, buf, bufsize); 282| | 283| |# endif 284| |#else 285| |# if SETLOCALE_NULL_ONE_MTSAFE 286| | 287| | if (category == LC_ALL) 288| | return setlocale_null_with_lock (category, buf, bufsize); 289| | else 290| | return setlocale_null_unlocked (category, buf, bufsize); 291| | 292| |# else 293| | 294| | return setlocale_null_with_lock (category, buf, bufsize); 295| | 296| |# endif 297| |#endif 298| 42.1k|} setlocale_null.c:setlocale_null_unlocked: 92| 42.1k|{ 93| |#if defined _WIN32 && !defined __CYGWIN__ && defined _MSC_VER 94| | /* On native Windows, nowadays, the setlocale() implementation is based 95| | on _wsetlocale() and uses malloc() for the result. We are better off 96| | using _wsetlocale() directly. */ 97| | const wchar_t *result = _wsetlocale (category, NULL); 98| | 99| | if (result == NULL) 100| | { 101| | /* CATEGORY is invalid. */ 102| | if (bufsize > 0) 103| | /* Return an empty string in BUF. 104| | This is a convenience for callers that don't want to write explicit 105| | code for handling EINVAL. */ 106| | buf[0] = '\0'; 107| | return EINVAL; 108| | } 109| | else 110| | { 111| | size_t length = wcslen (result); 112| | if (length < bufsize) 113| | { 114| | size_t i; 115| | 116| | /* Convert wchar_t[] -> char[], assuming plain ASCII. */ 117| | for (i = 0; i <= length; i++) 118| | buf[i] = result[i]; 119| | 120| | return 0; 121| | } 122| | else 123| | { 124| | if (bufsize > 0) 125| | { 126| | /* Return a truncated result in BUF. 127| | This is a convenience for callers that don't want to write 128| | explicit code for handling ERANGE. */ 129| | size_t i; 130| | 131| | /* Convert wchar_t[] -> char[], assuming plain ASCII. */ 132| | for (i = 0; i < bufsize; i++) 133| | buf[i] = result[i]; 134| | buf[bufsize - 1] = '\0'; 135| | } 136| | return ERANGE; 137| | } 138| | } 139| |#else 140| 42.1k| const char *result = setlocale_null_androidfix (category); 141| | 142| 42.1k| if (result == NULL) ------------------ | Branch (142:7): [True: 0, False: 42.1k] ------------------ 143| 0| { 144| | /* CATEGORY is invalid. */ 145| 0| if (bufsize > 0) ------------------ | Branch (145:11): [True: 0, False: 0] ------------------ 146| | /* Return an empty string in BUF. 147| | This is a convenience for callers that don't want to write explicit 148| | code for handling EINVAL. */ 149| 0| buf[0] = '\0'; 150| 0| return EINVAL; 151| 0| } 152| 42.1k| else 153| 42.1k| { 154| 42.1k| size_t length = strlen (result); 155| 42.1k| if (length < bufsize) ------------------ | Branch (155:11): [True: 42.1k, False: 0] ------------------ 156| 42.1k| { 157| 42.1k| memcpy (buf, result, length + 1); 158| 42.1k| return 0; 159| 42.1k| } 160| 0| else 161| 0| { 162| 0| if (bufsize > 0) ------------------ | Branch (162:15): [True: 0, False: 0] ------------------ 163| 0| { 164| | /* Return a truncated result in BUF. 165| | This is a convenience for callers that don't want to write 166| | explicit code for handling ERANGE. */ 167| 0| memcpy (buf, result, bufsize - 1); 168| 0| buf[bufsize - 1] = '\0'; 169| 0| } 170| 0| return ERANGE; 171| 0| } 172| 42.1k| } 173| 42.1k|#endif 174| 42.1k|} setlocale_null.c:setlocale_null_androidfix: 61| 42.1k|{ 62| 42.1k| const char *result = setlocale (category, NULL); 63| | 64| |#ifdef __ANDROID__ 65| | if (result == NULL) 66| | switch (category) 67| | { 68| | case LC_CTYPE: 69| | case LC_NUMERIC: 70| | case LC_TIME: 71| | case LC_COLLATE: 72| | case LC_MONETARY: 73| | case LC_MESSAGES: 74| | case LC_ALL: 75| | case LC_PAPER: 76| | case LC_NAME: 77| | case LC_ADDRESS: 78| | case LC_TELEPHONE: 79| | case LC_MEASUREMENT: 80| | result = "C"; 81| | break; 82| | default: 83| | break; 84| | } 85| |#endif 86| | 87| 42.1k| return result; 88| 42.1k|} xmalloc: 44| 786|{ 45| 786| return nonnull (malloc (s)); 46| 786|} xcalloc: 297| 4.71k|{ 298| 4.71k| return nonnull (calloc (n, s)); 299| 4.71k|} xmalloc.c:nonnull: 34| 5.50k|{ 35| 5.50k| if (!p) ------------------ | Branch (35:7): [True: 0, False: 5.50k] ------------------ 36| 0| xalloc_die (); 37| 5.50k| return p; 38| 5.50k|} c_isdigit: 232| 4|{ 233| 4| switch (c) 234| 4| { 235| 4| _C_CTYPE_DIGIT: ------------------ | | 133| 4| case '0': case '1': case '2': case '3': \ | | ------------------ | | | Branch (133:4): [True: 0, False: 4] | | | Branch (133:14): [True: 4, False: 0] | | | Branch (133:24): [True: 0, False: 4] | | | Branch (133:34): [True: 0, False: 4] | | ------------------ | | 134| 4| case '4': case '5': case '6': case '7': \ | | ------------------ | | | Branch (134:4): [True: 0, False: 4] | | | Branch (134:14): [True: 0, False: 4] | | | Branch (134:24): [True: 0, False: 4] | | | Branch (134:34): [True: 0, False: 4] | | ------------------ | | 135| 4| case '8': case '9' | | ------------------ | | | Branch (135:4): [True: 0, False: 4] | | ------------------ ------------------ 236| 4| return true; 237| 0| default: ------------------ | Branch (237:5): [True: 0, False: 4] ------------------ 238| 0| return false; 239| 4| } 240| 4|} c_tolower: 336| 9.43k|{ 337| 9.43k| switch (c) 338| 9.43k| { 339| 0| _C_CTYPE_UPPER: ------------------ | | 146| 0|#define _C_CTYPE_UPPER _C_CTYPE_LOWER_N ('A' - 'a') | | ------------------ | | | | 120| 0| _C_CTYPE_LOWER_A_THRU_F_N(N): \ | | | | ------------------ | | | | | | 117| 0| case 'a' + (N): case 'b' + (N): case 'c' + (N): case 'd' + (N): \ | | | | | | ------------------ | | | | | | | Branch (117:4): [True: 0, False: 9.43k] | | | | | | | Branch (117:20): [True: 0, False: 9.43k] | | | | | | | Branch (117:36): [True: 0, False: 9.43k] | | | | | | | Branch (117:52): [True: 0, False: 9.43k] | | | | | | ------------------ | | | | | | 118| 0| case 'e' + (N): case 'f' + (N) | | | | | | ------------------ | | | | | | | Branch (118:4): [True: 0, False: 9.43k] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (120:4): [True: 0, False: 9.43k] | | | | ------------------ | | | | 121| 0| case 'g' + (N): case 'h' + (N): case 'i' + (N): case 'j' + (N): \ | | | | ------------------ | | | | | Branch (121:4): [True: 0, False: 9.43k] | | | | | Branch (121:20): [True: 0, False: 9.43k] | | | | | Branch (121:36): [True: 0, False: 9.43k] | | | | | Branch (121:52): [True: 0, False: 9.43k] | | | | ------------------ | | | | 122| 0| case 'k' + (N): case 'l' + (N): case 'm' + (N): case 'n' + (N): \ | | | | ------------------ | | | | | Branch (122:4): [True: 0, False: 9.43k] | | | | | Branch (122:20): [True: 0, False: 9.43k] | | | | | Branch (122:36): [True: 0, False: 9.43k] | | | | | Branch (122:52): [True: 0, False: 9.43k] | | | | ------------------ | | | | 123| 0| case 'o' + (N): case 'p' + (N): case 'q' + (N): case 'r' + (N): \ | | | | ------------------ | | | | | Branch (123:4): [True: 0, False: 9.43k] | | | | | Branch (123:20): [True: 0, False: 9.43k] | | | | | Branch (123:36): [True: 0, False: 9.43k] | | | | | Branch (123:52): [True: 0, False: 9.43k] | | | | ------------------ | | | | 124| 0| case 's' + (N): case 't' + (N): case 'u' + (N): case 'v' + (N): \ | | | | ------------------ | | | | | Branch (124:4): [True: 0, False: 9.43k] | | | | | Branch (124:20): [True: 0, False: 9.43k] | | | | | Branch (124:36): [True: 0, False: 9.43k] | | | | | Branch (124:52): [True: 0, False: 9.43k] | | | | ------------------ | | | | 125| 0| case 'w' + (N): case 'x' + (N): case 'y' + (N): case 'z' + (N) | | | | ------------------ | | | | | Branch (125:4): [True: 0, False: 9.43k] | | | | | Branch (125:20): [True: 0, False: 9.43k] | | | | | Branch (125:36): [True: 0, False: 9.43k] | | | | ------------------ | | ------------------ ------------------ 340| 0| return c - 'A' + 'a'; 341| 9.43k| default: ------------------ | Branch (341:5): [True: 9.43k, False: 0] ------------------ 342| 9.43k| return c; 343| 9.43k| } 344| 9.43k|} is_basic: 309| 394k|{ 310| 394k| return (is_basic_table [(unsigned char) c >> 5] >> ((unsigned char) c & 31)) 311| 394k| & 1; 312| 394k|} mb_width_aux: 240| 349k|{ 241| 349k| int w = wcwidth (wc); 242| | /* For unprintable characters, arbitrarily return 0 for control characters 243| | and MB_UNPRINTABLE_WIDTH otherwise. */ 244| 349k| return (w >= 0 ? w : iswcntrl (wc) ? 0 : MB_UNPRINTABLE_WIDTH); ------------------ | | 236| 0|#define MB_UNPRINTABLE_WIDTH 1 ------------------ | Branch (244:11): [True: 349k, False: 0] | Branch (244:24): [True: 0, False: 0] ------------------ 245| 349k|} mbiter_multi_next: 117| 394k|{ 118| 394k| if (iter->next_done) ------------------ | Branch (118:7): [True: 0, False: 394k] ------------------ 119| 0| return; 120| 394k| if (iter->in_shift) ------------------ | Branch (120:7): [True: 0, False: 394k] ------------------ 121| 0| goto with_shift; 122| | /* Handle most ASCII characters quickly, without calling mbrtowc(). */ 123| 394k| if (is_basic (*iter->cur.ptr)) ------------------ | Branch (123:7): [True: 347k, False: 46.5k] ------------------ 124| 347k| { 125| | /* These characters are part of the basic character set. ISO C 99 126| | guarantees that their wide character code is identical to their 127| | char code. */ 128| 347k| iter->cur.bytes = 1; 129| 347k| iter->cur.wc = *iter->cur.ptr; 130| 347k| iter->cur.wc_valid = true; 131| 347k| } 132| 46.5k| else 133| 46.5k| { 134| 46.5k| assert (mbsinit (&iter->state)); 135| 46.5k| iter->in_shift = true; 136| 46.5k| with_shift: 137| 46.5k| iter->cur.bytes = mbrtowc (&iter->cur.wc, iter->cur.ptr, 138| 46.5k| iter->limit - iter->cur.ptr, &iter->state); 139| 46.5k| if (iter->cur.bytes == (size_t) -1) ------------------ | Branch (139:11): [True: 0, False: 46.5k] ------------------ 140| 0| { 141| | /* An invalid multibyte sequence was encountered. */ 142| 0| iter->cur.bytes = 1; 143| 0| iter->cur.wc_valid = false; 144| | /* Whether to set iter->in_shift = false and reset iter->state 145| | or not is not very important; the string is bogus anyway. */ 146| 0| } 147| 46.5k| else if (iter->cur.bytes == (size_t) -2) ------------------ | Branch (147:16): [True: 0, False: 46.5k] ------------------ 148| 0| { 149| | /* An incomplete multibyte character at the end. */ 150| 0| iter->cur.bytes = iter->limit - iter->cur.ptr; 151| 0| iter->cur.wc_valid = false; 152| | /* Whether to set iter->in_shift = false and reset iter->state 153| | or not is not important; the string end is reached anyway. */ 154| 0| } 155| 46.5k| else 156| 46.5k| { 157| 46.5k| if (iter->cur.bytes == 0) ------------------ | Branch (157:15): [True: 0, False: 46.5k] ------------------ 158| 0| { 159| | /* A null wide character was encountered. */ 160| 0| iter->cur.bytes = 1; 161| 0| assert (*iter->cur.ptr == '\0'); 162| 0| assert (iter->cur.wc == 0); 163| 0| } 164| 46.5k| iter->cur.wc_valid = true; 165| | 166| | /* When in the initial state, we can go back treating ASCII 167| | characters more quickly. */ 168| 46.5k| if (mbsinit (&iter->state)) ------------------ | Branch (168:15): [True: 46.5k, False: 0] ------------------ 169| 46.5k| iter->in_shift = false; 170| 46.5k| } 171| 46.5k| } 172| 394k| iter->next_done = true; 173| 394k|} logputs: 365| 311k|{ 366| 311k| FILE *fp; 367| 311k| FILE *warcfp; 368| 311k| int errno_save = errno; 369| | 370| 311k| check_redirect_output (); 371| 311k| if (o == LOG_PROGRESS) ------------------ | Branch (371:7): [True: 310k, False: 1.57k] ------------------ 372| 310k| fp = get_progress_fp (); 373| 1.57k| else 374| 1.57k| fp = get_log_fp (); 375| | 376| 311k| errno = errno_save; 377| | 378| 311k| if (fp == NULL) ------------------ | Branch (378:7): [True: 0, False: 311k] ------------------ 379| 0| return; 380| | 381| 311k| warcfp = get_warc_log_fp (); 382| 311k| errno = errno_save; 383| | 384| 311k| CHECK_VERBOSE (o); ------------------ | | 288| 311k| switch (x) \ | | ------------------ | | | Branch (288:11): [True: 0, False: 311k] | | ------------------ | | 289| 311k| { \ | | 290| 310k| case LOG_PROGRESS: \ | | ------------------ | | | Branch (290:5): [True: 310k, False: 1.57k] | | ------------------ | | 291| 310k| if (!opt.show_progress) \ | | ------------------ | | | Branch (291:11): [True: 310k, False: 0] | | ------------------ | | 292| 310k| return; \ | | 293| 310k| break; \ | | 294| 310k| case LOG_ALWAYS: \ | | ------------------ | | | Branch (294:5): [True: 0, False: 311k] | | ------------------ | | 295| 0| break; \ | | 296| 310k| case LOG_NOTQUIET: \ | | ------------------ | | | Branch (296:5): [True: 0, False: 311k] | | ------------------ | | 297| 0| if (opt.quiet) \ | | ------------------ | | | Branch (297:11): [True: 0, False: 0] | | ------------------ | | 298| 0| return; \ | | 299| 0| break; \ | | 300| 0| case LOG_NONVERBOSE: \ | | ------------------ | | | Branch (300:5): [True: 0, False: 311k] | | ------------------ | | 301| 0| if (opt.verbose || opt.quiet) \ | | ------------------ | | | Branch (301:11): [True: 0, False: 0] | | | Branch (301:26): [True: 0, False: 0] | | ------------------ | | 302| 0| return; \ | | 303| 0| break; \ | | 304| 1.57k| case LOG_VERBOSE: \ | | ------------------ | | | Branch (304:5): [True: 1.57k, False: 310k] | | ------------------ | | 305| 1.57k| if (!opt.verbose) \ | | ------------------ | | | Branch (305:11): [True: 1.57k, False: 0] | | ------------------ | | 306| 1.57k| return; \ | | 307| 311k| } ------------------ 385| | 386| 0| FPUTS (s, fp); ------------------ | | 55| 0|# define FPUTS( s, f) fputs( (s), (f)) ------------------ 387| 0| if (warcfp != NULL) ------------------ | Branch (387:7): [True: 0, False: 0] ------------------ 388| 0| FPUTS (s, warcfp); ------------------ | | 55| 0|# define FPUTS( s, f) fputs( (s), (f)) ------------------ 389| 0| if (save_context_p) ------------------ | Branch (389:7): [True: 0, False: 0] ------------------ 390| 0| saved_append (s); 391| 0| if (flush_log_p) ------------------ | Branch (391:7): [True: 0, False: 0] ------------------ 392| 0| logflush (); 393| 0| else 394| 0| needs_flushing = true; 395| | 396| 0| errno = errno_save; 397| 0|} log_set_flush: 529| 18.8k|{ 530| 18.8k| if (flush == flush_log_p) ------------------ | Branch (530:7): [True: 6.28k, False: 12.5k] ------------------ 531| 6.28k| return; 532| | 533| 12.5k| if (flush == false) ------------------ | Branch (533:7): [True: 6.28k, False: 6.28k] ------------------ 534| 6.28k| { 535| | /* Disable flushing by setting flush_log_p to 0. */ 536| 6.28k| flush_log_p = false; 537| 6.28k| } 538| 6.28k| else 539| 6.28k| { 540| | /* Re-enable flushing. If anything was printed in no-flush mode, 541| | flush the log now. */ 542| 6.28k| if (needs_flushing) ------------------ | Branch (542:11): [True: 0, False: 6.28k] ------------------ 543| 0| logflush (); 544| 6.28k| flush_log_p = true; 545| 6.28k| } 546| 12.5k|} log_set_save_context: 554| 4.31k|{ 555| 4.31k| bool old = save_context_p; 556| 4.31k| save_context_p = savep; 557| 4.31k| return old; 558| 4.31k|} logprintf: 566| 27.5k|{ 567| 27.5k| va_list args; 568| 27.5k| struct logvprintf_state lpstate; 569| 27.5k| bool done; 570| 27.5k| int errno_saved = errno; 571| | 572| 27.5k| CHECK_VERBOSE (o); ------------------ | | 288| 27.5k| switch (x) \ | | ------------------ | | | Branch (288:11): [True: 0, False: 27.5k] | | ------------------ | | 289| 27.5k| { \ | | 290| 27.5k| case LOG_PROGRESS: \ | | ------------------ | | | Branch (290:5): [True: 27.5k, False: 0] | | ------------------ | | 291| 27.5k| if (!opt.show_progress) \ | | ------------------ | | | Branch (291:11): [True: 27.5k, False: 0] | | ------------------ | | 292| 27.5k| return; \ | | 293| 27.5k| break; \ | | 294| 27.5k| case LOG_ALWAYS: \ | | ------------------ | | | Branch (294:5): [True: 0, False: 27.5k] | | ------------------ | | 295| 0| break; \ | | 296| 27.5k| case LOG_NOTQUIET: \ | | ------------------ | | | Branch (296:5): [True: 0, False: 27.5k] | | ------------------ | | 297| 0| if (opt.quiet) \ | | ------------------ | | | Branch (297:11): [True: 0, False: 0] | | ------------------ | | 298| 0| return; \ | | 299| 0| break; \ | | 300| 0| case LOG_NONVERBOSE: \ | | ------------------ | | | Branch (300:5): [True: 0, False: 27.5k] | | ------------------ | | 301| 0| if (opt.verbose || opt.quiet) \ | | ------------------ | | | Branch (301:11): [True: 0, False: 0] | | | Branch (301:26): [True: 0, False: 0] | | ------------------ | | 302| 0| return; \ | | 303| 0| break; \ | | 304| 0| case LOG_VERBOSE: \ | | ------------------ | | | Branch (304:5): [True: 0, False: 27.5k] | | ------------------ | | 305| 0| if (!opt.verbose) \ | | ------------------ | | | Branch (305:11): [True: 0, False: 0] | | ------------------ | | 306| 0| return; \ | | 307| 27.5k| } ------------------ 573| | 574| 0| check_redirect_output (); 575| 0| errno = errno_saved; 576| 0| if (inhibit_logging) ------------------ | Branch (576:7): [True: 0, False: 0] ------------------ 577| 0| return; 578| | 579| 0| xzero (lpstate); ------------------ | | 178| 0|#define xzero(x) memset (&(x), '\0', sizeof (x)) ------------------ 580| 0| errno = 0; 581| 0| do 582| 0| { 583| 0| va_start (args, fmt); 584| 0| done = log_vprintf_internal (&lpstate, fmt, args); 585| 0| va_end (args); 586| | 587| 0| if (done && errno == EPIPE) ------------------ | Branch (587:11): [True: 0, False: 0] | Branch (587:19): [True: 0, False: 0] ------------------ 588| 0| exit (WGET_EXIT_GENERIC_ERROR); ------------------ | | 321| 0|# define exit(status) exit_wget(status) ------------------ 589| 0| } 590| 0| while (!done); ------------------ | Branch (590:10): [True: 0, False: 0] ------------------ 591| | 592| 0| errno = errno_saved; 593| 0|} log.c:get_progress_fp: 327| 310k|{ 328| 310k| if (opt.show_progress == true) ------------------ | Branch (328:7): [True: 0, False: 310k] ------------------ 329| 0| return stderr; 330| 310k| return get_log_fp(); 331| 310k|} log.c:get_log_fp: 317| 311k|{ 318| 311k| if (inhibit_logging) ------------------ | Branch (318:7): [True: 0, False: 311k] ------------------ 319| 0| return NULL; 320| 311k| if (logfp) ------------------ | Branch (320:7): [True: 0, False: 311k] ------------------ 321| 0| return logfp; 322| 311k| return stderr; 323| 311k|} log.c:get_warc_log_fp: 342| 311k|{ 343| 311k| if (inhibit_logging) ------------------ | Branch (343:7): [True: 0, False: 311k] ------------------ 344| 0| return NULL; 345| 311k| if (warclogfp) ------------------ | Branch (345:7): [True: 0, False: 311k] ------------------ 346| 0| return warclogfp; 347| 311k| if (logfp) ------------------ | Branch (347:7): [True: 0, False: 311k] ------------------ 348| 0| return NULL; 349| 311k| return stderr; 350| 311k|} log.c:check_redirect_output: 974| 311k|{ 975| 311k|#if !defined(WINDOWS) && !defined(__VMS) 976| | /* If it was redirected already to log file by SIGHUP, SIGUSR1 or -o parameter, 977| | * it was permanent. 978| | * If there was no SIGHUP or SIGUSR1 and shell is interactive 979| | * we check if process is fg or bg before every line is printed.*/ 980| 311k| if (!redirect_request_signal_name && shell_is_interactive && !opt.lfilename) ------------------ | Branch (980:7): [True: 311k, False: 0] | Branch (980:40): [True: 0, False: 311k] | Branch (980:64): [True: 0, False: 0] ------------------ 981| 0| { 982| 0| pid_t foreground_pgrp = tcgetpgrp (STDIN_FILENO); 983| | 984| 0| if (foreground_pgrp != -1 && foreground_pgrp != getpgrp () && !opt.quiet) ------------------ | Branch (984:11): [True: 0, False: 0] | Branch (984:36): [True: 0, False: 0] | Branch (984:69): [True: 0, False: 0] ------------------ 985| 0| { 986| | /* Process backgrounded */ 987| 0| redirect_output (true,NULL); 988| 0| } 989| 0| else 990| 0| { 991| | /* Process foregrounded */ 992| 0| redirect_output (false,NULL); 993| 0| } 994| 0| } 995| 311k|#endif /* !defined(WINDOWS) && !defined(__VMS) */ 996| 311k|} set_progress_implementation: 112| 3.93k|{ 113| 3.93k| size_t i, namelen; 114| 3.93k| struct progress_implementation *pi = implementations; 115| 3.93k| const char *colon; 116| | 117| 3.93k| if (!name) ------------------ | Branch (117:7): [True: 0, False: 3.93k] ------------------ 118| 0| name = DEFAULT_PROGRESS_IMPLEMENTATION; ------------------ | | 81| 0|#define DEFAULT_PROGRESS_IMPLEMENTATION "bar" ------------------ 119| | 120| 3.93k| colon = strchr (name, ':'); 121| 3.93k| namelen = colon ? (size_t) (colon - name) : strlen (name); ------------------ | Branch (121:13): [True: 3.93k, False: 0] ------------------ 122| | 123| 4.71k| for (i = 0; i < countof (implementations); i++, pi++) ------------------ | | 175| 4.71k|#define countof(array) (sizeof (array) / sizeof ((array)[0])) ------------------ | Branch (123:15): [True: 4.71k, False: 0] ------------------ 124| 4.71k| if (!strncmp (pi->name, name, namelen)) ------------------ | Branch (124:9): [True: 3.93k, False: 786] ------------------ 125| 3.93k| { 126| 3.93k| current_impl = pi; 127| 3.93k| current_impl_locked = 0; 128| | 129| 3.93k| if (colon) ------------------ | Branch (129:13): [True: 3.93k, False: 0] ------------------ 130| | /* We call pi->set_params even if colon is NULL because we 131| | want to give the implementation a chance to set up some 132| | things it needs to run. */ 133| 3.93k| ++colon; 134| | 135| 3.93k| if (pi->set_params) ------------------ | Branch (135:13): [True: 3.93k, False: 0] ------------------ 136| 3.93k| pi->set_params (colon); 137| 3.93k| return; 138| 3.93k| } 139| 0| abort (); 140| 3.93k|} progress_create: 158| 3.93k|{ 159| | /* Check if the log status has changed under our feet. */ 160| 3.93k| if (output_redirected) ------------------ | Branch (160:7): [True: 0, False: 3.93k] ------------------ 161| 0| { 162| 0| if (!current_impl_locked) ------------------ | Branch (162:11): [True: 0, False: 0] ------------------ 163| 0| set_progress_implementation (FALLBACK_PROGRESS_IMPLEMENTATION); ------------------ | | 89| 0|#define FALLBACK_PROGRESS_IMPLEMENTATION "dot" ------------------ 164| 0| output_redirected = 0; 165| 0| } 166| | 167| 3.93k| return current_impl->create (f_download, initial, total); 168| 3.93k|} progress_update: 186| 7.86k|{ 187| | // sanitize input 188| 7.86k| if (dltime >= INT_MAX) ------------------ | Branch (188:7): [True: 4.71k, False: 3.15k] ------------------ 189| 4.71k| dltime = INT_MAX - 1; 190| 3.15k| else if (dltime < 0) ------------------ | Branch (190:12): [True: 1.90k, False: 1.25k] ------------------ 191| 1.90k| dltime = 0; 192| | 193| 7.86k| if (howmuch < 0) ------------------ | Branch (193:7): [True: 0, False: 7.86k] ------------------ 194| 0| howmuch = 0; 195| | 196| 7.86k| current_impl->update (progress, howmuch, dltime); 197| 7.86k| current_impl->draw (progress); 198| 7.86k|} progress_finish: 205| 3.93k|{ 206| | // sanitize input 207| 3.93k| if (dltime >= INT_MAX) ------------------ | Branch (207:7): [True: 2.35k, False: 1.57k] ------------------ 208| 2.35k| dltime = INT_MAX - 1; 209| 1.57k| else if (dltime < 0) ------------------ | Branch (209:12): [True: 950, False: 625] ------------------ 210| 950| dltime = 0; 211| | 212| 3.93k| current_impl->finish (progress, dltime); 213| 3.93k|} progress.c:dot_create: 237| 3.14k|{ 238| 3.14k| struct dot_progress *dp = xnew0 (struct dot_progress); ------------------ | | 50| 3.14k|#define xnew0(type) (xcalloc (1, sizeof (type))) ------------------ 239| 3.14k| dp->initial_length = initial; 240| 3.14k| dp->total_length = total; 241| | 242| 3.14k| if (dp->initial_length) ------------------ | Branch (242:7): [True: 2.96k, False: 180] ------------------ 243| 2.96k| { 244| 2.96k| int dot_bytes = opt.dot_bytes; 245| 2.96k| const wgint ROW_BYTES = opt.dot_bytes * opt.dots_in_line; 246| | 247| 2.96k| int remainder = dp->initial_length % ROW_BYTES; 248| 2.96k| wgint skipped = dp->initial_length - remainder; 249| | 250| 2.96k| if (skipped) ------------------ | Branch (250:11): [True: 2.41k, False: 551] ------------------ 251| 2.41k| { 252| 2.41k| wgint skipped_k = skipped / 1024; /* skipped amount in K */ 253| 2.41k| int skipped_k_len = numdigit (skipped_k); 254| 2.41k| if (skipped_k_len < 6) ------------------ | Branch (254:15): [True: 273, False: 2.14k] ------------------ 255| 273| skipped_k_len = 6; 256| | 257| | /* Align the [ skipping ... ] line with the dots. To do 258| | that, insert the number of spaces equal to the number of 259| | digits in the skipped amount in K. */ 260| 2.41k| logprintf (LOG_PROGRESS, _("\n%*s[ skipping %sK ]"), ------------------ | | 64| 2.41k|#define _(STRING) gettext(STRING) ------------------ 261| 2.41k| 2 + skipped_k_len, "", 262| 2.41k| number_to_static_string (skipped_k)); 263| 2.41k| } 264| | 265| 2.96k| logprintf (LOG_PROGRESS, "\n%6sK", 266| 2.96k| number_to_static_string (skipped / 1024)); 267| 54.5k| for (; remainder >= dot_bytes; remainder -= dot_bytes) ------------------ | Branch (267:14): [True: 51.5k, False: 2.96k] ------------------ 268| 51.5k| { 269| 51.5k| if (dp->dots % opt.dot_spacing == 0) ------------------ | Branch (269:15): [True: 6.02k, False: 45.5k] ------------------ 270| 6.02k| logputs (LOG_PROGRESS, " "); 271| 51.5k| logputs (LOG_PROGRESS, ","); 272| 51.5k| ++dp->dots; 273| 51.5k| } 274| 2.96k| assert (dp->dots < opt.dots_in_line); 275| | 276| 2.96k| dp->accumulated = remainder; 277| 2.96k| dp->rows = skipped / ROW_BYTES; 278| 2.96k| } 279| | 280| 3.14k| return dp; 281| 3.14k|} progress.c:dot_update: 393| 6.28k|{ 394| | // sanitize input 395| 6.28k| if (dltime >= INT_MAX) ------------------ | Branch (395:7): [True: 0, False: 6.28k] ------------------ 396| 0| dltime = INT_MAX - 1; 397| 6.28k| else if (dltime < 0) ------------------ | Branch (397:12): [True: 0, False: 6.28k] ------------------ 398| 0| dltime = 0; 399| | 400| 6.28k| if (howmuch < 0) ------------------ | Branch (400:7): [True: 0, False: 6.28k] ------------------ 401| 0| howmuch = 0; 402| | 403| 6.28k| struct dot_progress *dp = progress; 404| 6.28k| dp->accumulated += howmuch; 405| 6.28k| dp->dltime = dltime; 406| 6.28k|} progress.c:dot_draw: 410| 6.28k|{ 411| 6.28k| struct dot_progress *dp = progress; 412| 6.28k| int dot_bytes = opt.dot_bytes; 413| 6.28k| wgint ROW_BYTES = opt.dot_bytes * opt.dots_in_line; 414| | 415| 6.28k| log_set_flush (false); 416| | 417| 151k| while (dp->accumulated >= dot_bytes) ------------------ | Branch (417:10): [True: 145k, False: 6.28k] ------------------ 418| 145k| { 419| 145k| dp->accumulated -= dot_bytes; 420| 145k| if (dp->dots == 0) ------------------ | Branch (420:11): [True: 3.34k, False: 141k] ------------------ 421| 3.34k| logprintf (LOG_PROGRESS, "\n%6sK", 422| 3.34k| number_to_static_string (dp->rows * ROW_BYTES / 1024)); 423| | 424| 145k| if (dp->dots % opt.dot_spacing == 0) ------------------ | Branch (424:11): [True: 14.7k, False: 130k] ------------------ 425| 14.7k| logputs (LOG_PROGRESS, " "); 426| 145k| logputs (LOG_PROGRESS, "."); 427| | 428| 145k| ++dp->dots; 429| 145k| if (dp->dots >= opt.dots_in_line) ------------------ | Branch (429:11): [True: 3.01k, False: 142k] ------------------ 430| 3.01k| { 431| 3.01k| dp->dots = 0; 432| 3.01k|#if ADD_DOT_ROWS_THRS 433| 3.01k| { 434| 3.01k| wgint added_rows = 1; 435| 3.01k| if (dp->accumulated >= (ROW_BYTES << ADD_DOT_ROWS_THRS)) ------------------ | | 294| 3.01k|#define ADD_DOT_ROWS_THRS 2 ------------------ | Branch (435:17): [True: 2.72k, False: 288] ------------------ 436| 2.72k| { 437| 2.72k| added_rows += dp->accumulated / ROW_BYTES; 438| 2.72k| dp->accumulated %= ROW_BYTES; 439| 2.72k| } 440| 3.01k| if (WGINT_MAX - dp->rows >= added_rows) ------------------ | | 145| 3.01k|#define WGINT_MAX INT64_MAX ------------------ | Branch (440:17): [True: 3.01k, False: 0] ------------------ 441| 3.01k| dp->rows += added_rows; 442| 0| else 443| 0| dp->rows = WGINT_MAX; ------------------ | | 145| 0|#define WGINT_MAX INT64_MAX ------------------ 444| 3.01k| print_row_stats (dp, dp->dltime, false, added_rows); 445| 3.01k| } 446| |#else 447| | if (dp->rows < WGINT_MAX) 448| | ++dp->rows; 449| | print_row_stats (dp, dp->dltime, false); 450| |#endif /* ADD_DOT_ROWS_THRS */ 451| 3.01k| } 452| 145k| } 453| | 454| 6.28k| log_set_flush (true); 455| 6.28k|} progress.c:print_row_stats: 314| 6.15k|{ 315| 6.15k| const wgint ROW_BYTES = opt.dot_bytes * opt.dots_in_line; 316| | 317| | /* bytes_displayed is the number of bytes indicated to the user by 318| | dots printed so far, includes the initially "skipped" amount */ 319| 6.15k| wgint bytes_displayed = dp->rows * ROW_BYTES + dp->dots * opt.dot_bytes; 320| | 321| 6.15k| if (last) ------------------ | Branch (321:7): [True: 3.14k, False: 3.01k] ------------------ 322| | /* For last row also count bytes accumulated after last dot */ 323| 3.14k| bytes_displayed += dp->accumulated; 324| | 325| 6.15k| if (bytes_displayed < 0) ------------------ | Branch (325:7): [True: 0, False: 6.15k] ------------------ 326| 0| bytes_displayed = 0; 327| | 328| 6.15k| if (dp->total_length) ------------------ | Branch (328:7): [True: 6.14k, False: 12] ------------------ 329| 6.14k| { 330| | /* Round to floor value to provide gauge how much data *has* 331| | been retrieved. 12.8% will round to 12% because the 13% mark 332| | has not yet been reached. 100% is only shown when done. */ 333| 6.14k| int percentage = 100.0 * bytes_displayed / dp->total_length; 334| 6.14k| logprintf (LOG_PROGRESS, "%3d%%", percentage); 335| 6.14k| } 336| | 337| 6.15k| { 338| 6.15k| static char names[] = {' ', 'K', 'M', 'G', 'T'}; 339| 6.15k| int units; 340| 6.15k| double rate; 341| 6.15k| wgint bytes_this_row; 342| 6.15k| if (!last) ------------------ | Branch (342:9): [True: 3.01k, False: 3.14k] ------------------ 343| 3.01k|#if ADD_DOT_ROWS_THRS 344| 3.01k| bytes_this_row = ROW_BYTES * added_rows; 345| |#else 346| | bytes_this_row = ROW_BYTES; 347| |#endif 348| 3.14k| else 349| | /* For last row also include bytes accumulated after last dot. */ 350| 3.14k| bytes_this_row = dp->dots * opt.dot_bytes + dp->accumulated; 351| | /* Don't count the portion of the row belonging to initial_length */ 352| 6.15k| if (dp->rows == dp->initial_length / ROW_BYTES) ------------------ | Branch (352:9): [True: 282, False: 5.87k] ------------------ 353| 282| bytes_this_row -= dp->initial_length % ROW_BYTES; 354| 6.15k| rate = calc_rate (bytes_this_row, dltime - dp->last_timer_value, &units); 355| 6.15k| logprintf (LOG_PROGRESS, " %4.*f%c", 356| 6.15k| rate >= 99.95 ? 0 : rate >= 9.995 ? 1 : 2, ------------------ | Branch (356:16): [True: 526, False: 5.63k] | Branch (356:36): [True: 410, False: 5.22k] ------------------ 357| 6.15k| rate, names[units]); 358| 6.15k| dp->last_timer_value = dltime; 359| 6.15k| } 360| | 361| 6.15k| if (!last) ------------------ | Branch (361:7): [True: 3.01k, False: 3.14k] ------------------ 362| 3.01k| { 363| | /* Display ETA based on average speed. Inspired by Vladi 364| | Belperchinov-Shabanski's "wget-new-percentage" patch. */ 365| 3.01k| if (dp->total_length) ------------------ | Branch (365:11): [True: 3.01k, False: 0] ------------------ 366| 3.01k| { 367| 3.01k| wgint bytes_remaining = dp->total_length > bytes_displayed ? dp->total_length - bytes_displayed : 0; ------------------ | Branch (367:35): [True: 2.88k, False: 127] ------------------ 368| | /* The quantity downloaded in this download run. */ 369| 3.01k| wgint bytes_sofar = bytes_displayed > dp->initial_length ? bytes_displayed - dp->initial_length : 1; ------------------ | Branch (369:31): [True: 3.01k, False: 0] ------------------ 370| 3.01k| double eta = dltime * bytes_remaining / bytes_sofar; 371| 3.01k| if (eta < 0) ------------------ | Branch (371:15): [True: 0, False: 3.01k] ------------------ 372| 0| eta = 0; 373| 3.01k| if (eta < INT_MAX - 1) ------------------ | Branch (373:15): [True: 2.94k, False: 66] ------------------ 374| 2.94k| logprintf (LOG_PROGRESS, " %s", 375| 2.94k| eta_to_human_short ((int) (eta + 0.5), true)); 376| 3.01k| } 377| 3.01k| } 378| 3.14k| else 379| 3.14k| { 380| | /* When done, print the total download time */ 381| 3.14k| if (dltime >= 10) ------------------ | Branch (381:11): [True: 2.29k, False: 848] ------------------ 382| 2.29k| logprintf (LOG_PROGRESS, "=%s", 383| 2.29k| eta_to_human_short ((int) (dltime + 0.5), true)); 384| 848| else 385| 848| logprintf (LOG_PROGRESS, "=%ss", print_decimal (dltime)); 386| 3.14k| } 387| 6.15k|} progress.c:eta_to_human_short: 1437| 5.81k|{ 1438| 5.81k| static char buf[16]; /* enough space to be on the safe side */ 1439| 5.81k| static int last = -1; 1440| 5.81k| const char *space = condensed ? "" : " "; ------------------ | Branch (1440:23): [True: 5.24k, False: 574] ------------------ 1441| | 1442| | /* Trivial optimization. create_image can call us every 200 msecs 1443| | (see bar_update) for fast downloads, but ETA will only change 1444| | once per 900 msecs. */ 1445| 5.81k| if (secs == last) ------------------ | Branch (1445:7): [True: 1.17k, False: 4.64k] ------------------ 1446| 1.17k| return buf; 1447| 4.64k| last = secs; 1448| | 1449| 4.64k| if (secs < 100) ------------------ | Branch (1449:7): [True: 1.76k, False: 2.87k] ------------------ 1450| 1.76k| sprintf (buf, "%ds", secs); 1451| 2.87k| else if (secs < 100 * 60) ------------------ | Branch (1451:12): [True: 222, False: 2.65k] ------------------ 1452| 222| sprintf (buf, "%dm%s%ds", secs / 60, space, secs % 60); 1453| 2.65k| else if (secs < 48 * 3600) ------------------ | Branch (1453:12): [True: 198, False: 2.45k] ------------------ 1454| 198| sprintf (buf, "%dh%s%dm", secs / 3600, space, (secs / 60) % 60); 1455| 2.45k| else if (secs < 100 * 86400) ------------------ | Branch (1455:12): [True: 235, False: 2.22k] ------------------ 1456| 235| sprintf (buf, "%dd%s%dh", secs / 86400, space, (secs / 3600) % 24); 1457| 2.22k| else 1458| | /* even (2^31-1)/86400 doesn't overflow BUF. */ 1459| 2.22k| sprintf (buf, "%dd", secs / 86400); 1460| | 1461| 4.64k| return buf; 1462| 5.81k|} progress.c:dot_finish: 461| 3.14k|{ 462| 3.14k| struct dot_progress *dp = progress; 463| 3.14k| wgint ROW_BYTES = opt.dot_bytes * opt.dots_in_line; 464| 3.14k| int i; 465| | 466| 3.14k| log_set_flush (false); 467| | 468| 3.14k| if (dp->dots == 0) ------------------ | Branch (468:7): [True: 486, False: 2.65k] ------------------ 469| 486| logprintf (LOG_PROGRESS, "\n%6sK", 470| 486| number_to_static_string (dp->rows * ROW_BYTES / 1024)); 471| 80.9k| for (i = dp->dots; i < opt.dots_in_line; i++) ------------------ | Branch (471:22): [True: 77.8k, False: 3.14k] ------------------ 472| 77.8k| { 473| 77.8k| if (i % opt.dot_spacing == 0) ------------------ | Branch (473:11): [True: 6.92k, False: 70.9k] ------------------ 474| 6.92k| logputs (LOG_PROGRESS, " "); 475| 77.8k| logputs (LOG_PROGRESS, " "); 476| 77.8k| } 477| | 478| | // sanitize input 479| 3.14k| if (dltime >= INT_MAX) ------------------ | Branch (479:7): [True: 0, False: 3.14k] ------------------ 480| 0| dltime = INT_MAX - 1; 481| 3.14k| else if (dltime < 0) ------------------ | Branch (481:12): [True: 0, False: 3.14k] ------------------ 482| 0| dltime = 0; 483| 3.14k|#if ADD_DOT_ROWS_THRS 484| 3.14k| print_row_stats (dp, dltime, true, 1); 485| |#else 486| | print_row_stats (dp, dltime, true); 487| |#endif 488| 3.14k| logputs (LOG_PROGRESS, "\n\n"); 489| 3.14k| log_set_flush (false); 490| | 491| 3.14k| xfree (dp); ------------------ | | 54| 3.14k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 492| 3.14k|} progress.c:dot_set_params: 501| 3.14k|{ 502| 3.14k| current_impl->interactive = false; 503| 3.14k| if (!params || !*params) ------------------ | Branch (503:7): [True: 0, False: 3.14k] | Branch (503:18): [True: 0, False: 3.14k] ------------------ 504| 0| params = opt.dot_style; 505| | 506| 3.14k| if (!params) ------------------ | Branch (506:7): [True: 0, False: 3.14k] ------------------ 507| 0| return; 508| | 509| | /* We use this to set the retrieval style. */ 510| 3.14k| if (!c_strcasecmp (params, "default")) ------------------ | Branch (510:7): [True: 786, False: 2.35k] ------------------ 511| 786| { 512| | /* Default style: 1K dots, 10 dots in a cluster, 50 dots in a 513| | line. */ 514| 786| opt.dot_bytes = 1024; 515| 786| opt.dot_spacing = 10; 516| 786| opt.dots_in_line = 50; 517| 786| } 518| 2.35k| else if (!c_strcasecmp (params, "binary")) ------------------ | Branch (518:12): [True: 786, False: 1.57k] ------------------ 519| 786| { 520| | /* "Binary" retrieval: 8K dots, 16 dots in a cluster, 48 dots 521| | (384K) in a line. */ 522| 786| opt.dot_bytes = 8192; 523| 786| opt.dot_spacing = 16; 524| 786| opt.dots_in_line = 48; 525| 786| } 526| 1.57k| else if (!c_strcasecmp (params, "mega")) ------------------ | Branch (526:12): [True: 786, False: 786] ------------------ 527| 786| { 528| | /* "Mega" retrieval, for retrieving very long files; each dot is 529| | 64K, 8 dots in a cluster, 6 clusters (3M) in a line. */ 530| 786| opt.dot_bytes = 65536L; 531| 786| opt.dot_spacing = 8; 532| 786| opt.dots_in_line = 48; 533| 786| } 534| 786| else if (!c_strcasecmp (params, "giga")) ------------------ | Branch (534:12): [True: 786, False: 0] ------------------ 535| 786| { 536| | /* "Giga" retrieval, for retrieving very very *very* long files; 537| | each dot is 1M, 8 dots in a cluster, 4 clusters (32M) in a 538| | line. */ 539| 786| opt.dot_bytes = (1L << 20); 540| 786| opt.dot_spacing = 8; 541| 786| opt.dots_in_line = 32; 542| 786| } 543| 0| else 544| 0| fprintf (stderr, 545| 0| _("Invalid dot style specification %s; leaving unchanged.\n"), ------------------ | | 64| 0|#define _(STRING) gettext(STRING) ------------------ 546| 0| quote (params)); 547| 3.14k|} progress.c:bar_create: 716| 786|{ 717| 786| struct bar_progress *bp = xnew0 (struct bar_progress); ------------------ | | 50| 786|#define xnew0(type) (xcalloc (1, sizeof (type))) ------------------ 718| | 719| | /* In theory, our callers should take care of this pathological 720| | case, but it can sometimes happen. */ 721| 786| if (initial > total) ------------------ | Branch (721:7): [True: 0, False: 786] ------------------ 722| 0| total = initial; 723| | 724| 786| bp->initial_length = initial; 725| 786| bp->total_length = total; 726| | /* Zero-width mbc must be replaced to avoid buffer overflow. 727| | Another way is to allocate a buffer that allows contain 728| | full f_download, but in this case some escape sequences may break "bar" */ 729| 786| bp->f_download = xmalloc (prepare_filename (NULL, f_download)); 730| 786| prepare_filename (bp->f_download, f_download); 731| | 732| | /* Initialize screen_width if this hasn't been done or if it might 733| | have changed, as indicated by receiving SIGWINCH. */ 734| 786| if (!screen_width || received_sigwinch) ------------------ | Branch (734:7): [True: 1, False: 785] | Branch (734:24): [True: 0, False: 785] ------------------ 735| 1| { 736| 1| screen_width = determine_screen_width (); 737| 1| if (!screen_width) ------------------ | Branch (737:11): [True: 1, False: 0] ------------------ 738| 1| screen_width = DEFAULT_SCREEN_WIDTH; ------------------ | | 552| 1|#define DEFAULT_SCREEN_WIDTH 80 ------------------ 739| 0| else if (screen_width < MINIMUM_SCREEN_WIDTH) ------------------ | | 558| 0|#define MINIMUM_SCREEN_WIDTH 51 ------------------ | Branch (739:16): [True: 0, False: 0] ------------------ 740| 0| screen_width = MINIMUM_SCREEN_WIDTH; ------------------ | | 558| 0|#define MINIMUM_SCREEN_WIDTH 51 ------------------ 741| 1| received_sigwinch = 0; 742| 1| } 743| | 744| | /* - 1 because we don't want to use the last screen column. */ 745| 786| bp->width = screen_width - 1; 746| | /* + enough space for the terminating zero, and hopefully enough room 747| | * for multibyte characters. */ 748| 786|#define BUF_LEN (bp->width * 2 + 100) 749| 786| bp->buffer = xcalloc (BUF_LEN, 1); ------------------ | | 748| 786|#define BUF_LEN (bp->width * 2 + 100) ------------------ 750| | 751| 786| logputs (LOG_VERBOSE, "\n"); 752| | 753| 786| create_image (bp, 0, false); 754| 786| display_image (bp->buffer); 755| | 756| 786| return bp; 757| 786|} progress.c:prepare_filename: 651| 1.57k|{ 652| 1.57k| size_t ret = 1; 653| 1.57k| if (src) ------------------ | Branch (653:7): [True: 1.57k, False: 0] ------------------ 654| 1.57k| { 655| 1.57k| mbi_iterator_t iter; 656| 1.57k| mbchar_t mbc; 657| 1.57k| mbi_init (iter, src, strlen (src)); ------------------ | | 197| 1.57k| ((iter).cur.ptr = (startptr), (iter).limit = (iter).cur.ptr + (length), \ | | 198| 1.57k| (iter).in_shift = false, memset (&(iter).state, '\0', sizeof (mbstate_t)), \ | | 199| 1.57k| (iter).next_done = false) ------------------ 658| 49.7k| while (mbi_avail (iter)) ------------------ | | 201| 49.7k| ((iter).cur.ptr < (iter).limit && (mbiter_multi_next (&(iter)), true)) | | ------------------ | | | Branch (201:4): [True: 48.1k, False: 1.57k] | | | Branch (201:37): [True: 48.1k, False: 0] | | ------------------ ------------------ 659| 48.1k| { 660| 48.1k| size_t i; 661| 48.1k| mbc = mbi_cur(iter); ------------------ | | 206| 48.1k|#define mbi_cur(iter) (iter).cur ------------------ 662| | /* replace invalid || unprintable || zero-width mbc ws hexdgt code */ 663| 48.1k| if (!mb_isprint (mbc) || !mb_width (mbc)) ------------------ | | 227| 96.3k|#define mb_isprint(mbc) ((mbc).wc_valid && iswprint ((mbc).wc)) | | ------------------ | | | Branch (227:26): [True: 48.1k, False: 0] | | | Branch (227:44): [True: 3.25k, False: 44.9k] | | ------------------ ------------------ if (!mb_isprint (mbc) || !mb_width (mbc)) ------------------ | | 248| 3.25k| ((mbc).wc_valid ? mb_width_aux ((mbc).wc) : MB_UNPRINTABLE_WIDTH) | | ------------------ | | | | 236| 0|#define MB_UNPRINTABLE_WIDTH 1 | | ------------------ | | | Branch (248:4): [True: 3.25k, False: 0] | | ------------------ ------------------ | Branch (663:36): [True: 0, False: 3.25k] ------------------ 664| 89.8k| for (i=0; i < mb_len (mbc); i++) ------------------ | | 177| 89.8k|#define mb_len(mbc) ((mbc).bytes) ------------------ | Branch (664:23): [True: 44.9k, False: 44.9k] ------------------ 665| 44.9k| { 666| 44.9k| if (dest) ------------------ | Branch (666:21): [True: 22.4k, False: 22.4k] ------------------ 667| 22.4k| dest += sprintf (dest, "%%%02x", (unsigned char) *(mb_ptr(mbc) + i)); ------------------ | | 176| 22.4k|#define mb_ptr(mbc) ((mbc).ptr) ------------------ 668| 44.9k| ret += 3; 669| 44.9k| } 670| 3.25k| else 671| 3.25k| { 672| 3.25k| if (dest) ------------------ | Branch (672:19): [True: 1.62k, False: 1.62k] ------------------ 673| 3.25k| for (i=0; i < mb_len (mbc); i++) ------------------ | | 177| 3.25k|#define mb_len(mbc) ((mbc).bytes) ------------------ | Branch (673:27): [True: 1.62k, False: 1.62k] ------------------ 674| 1.62k| *dest++ = *(mb_ptr (mbc) + i); ------------------ | | 176| 1.62k|#define mb_ptr(mbc) ((mbc).ptr) ------------------ 675| 3.25k| ret += mb_len (mbc); ------------------ | | 177| 3.25k|#define mb_len(mbc) ((mbc).bytes) ------------------ 676| 3.25k| } 677| 48.1k| mbi_advance (iter); ------------------ | | 203| 48.1k| ((iter).cur.ptr += (iter).cur.bytes, (iter).next_done = false) ------------------ 678| 48.1k| } 679| 1.57k| } 680| 1.57k| if (dest) ------------------ | Branch (680:7): [True: 786, False: 786] ------------------ 681| 786| *dest = 0; 682| 1.57k| return ret; 683| 1.57k|} progress.c:create_image: 1045| 2.15k|{ 1046| 2.15k| const int MAX_FILENAME_COLS = bp->width / 4; 1047| 2.15k| char *p = bp->buffer; 1048| 2.15k| wgint size = bp->initial_length + bp->count; 1049| | 1050| 2.15k| struct bar_progress_hist *hist = &bp->hist; 1051| 2.15k| int orig_filename_cols = count_cols (bp->f_download); 1052| | 1053| 2.15k| int padding; 1054| | 1055| | /* The progress bar should look like this: 1056| | file xx% [=======> ] nnn.nnK 12.34KB/s eta 36m 51s 1057| | 1058| | Calculate the geometry. The idea is to assign as much room as 1059| | possible to the progress bar. The other idea is to never let 1060| | things "jitter", i.e. pad elements that vary in size so that 1061| | their variance does not affect the placement of other elements. 1062| | It would be especially bad for the progress bar to be resized 1063| | randomly. 1064| | 1065| | "file " - Downloaded filename - MAX_FILENAME_COLS chars + 1 1066| | "xx% " or "100%" - percentage - 4 chars 1067| | "[]" - progress bar decorations - 2 chars 1068| | " nnn.nnK" - downloaded bytes - 7 chars + 1 1069| | " 12.5KB/s" - download rate - 8 chars + 1 1070| | " eta 36m 51s" - ETA - 14 chars 1071| | 1072| | "=====>..." - progress bar - the rest 1073| | */ 1074| | 1075| | /* TODO: Ask the Turkish Translators to fix their translation for the "done" 1076| | * mode of progress bar. Use one less character. Once that is done, redice 1077| | * PROGRESS_ETA_LEN by 1. 1078| | */ 1079| 2.15k|#define PROGRESS_FILENAME_LEN MAX_FILENAME_COLS + 1 1080| 2.15k|#define PROGRESS_PERCENT_LEN 4 1081| 2.15k|#define PROGRESS_DECORAT_LEN 2 1082| 2.15k|#define PROGRESS_FILESIZE_LEN 7 + 1 1083| 2.15k|#define PROGRESS_DWNLOAD_RATE 8 + 2 1084| 2.15k|#define PROGRESS_ETA_LEN 15 1085| | 1086| 2.15k| int progress_size = bp->width - (PROGRESS_FILENAME_LEN + PROGRESS_PERCENT_LEN + ------------------ | | 1079| 2.15k|#define PROGRESS_FILENAME_LEN MAX_FILENAME_COLS + 1 ------------------ int progress_size = bp->width - (PROGRESS_FILENAME_LEN + PROGRESS_PERCENT_LEN + ------------------ | | 1080| 2.15k|#define PROGRESS_PERCENT_LEN 4 ------------------ 1087| 2.15k| PROGRESS_DECORAT_LEN + PROGRESS_FILESIZE_LEN + ------------------ | | 1081| 2.15k|#define PROGRESS_DECORAT_LEN 2 ------------------ PROGRESS_DECORAT_LEN + PROGRESS_FILESIZE_LEN + ------------------ | | 1082| 2.15k|#define PROGRESS_FILESIZE_LEN 7 + 1 ------------------ 1088| 2.15k| PROGRESS_DWNLOAD_RATE + PROGRESS_ETA_LEN); ------------------ | | 1083| 2.15k|#define PROGRESS_DWNLOAD_RATE 8 + 2 ------------------ PROGRESS_DWNLOAD_RATE + PROGRESS_ETA_LEN); ------------------ | | 1084| 2.15k|#define PROGRESS_ETA_LEN 15 ------------------ 1089| | 1090| | /* The difference between the number of bytes used, 1091| | and the number of columns used. */ 1092| 2.15k| int bytes_cols_diff = 0; 1093| 2.15k| int cols_diff; 1094| 2.15k| const char *down_size; 1095| | 1096| 2.15k| if (progress_size < 5) ------------------ | Branch (1096:7): [True: 0, False: 2.15k] ------------------ 1097| 0| progress_size = 0; 1098| | 1099| | // sanitize input 1100| 2.15k| if (dl_total_time >= INT_MAX) ------------------ | Branch (1100:7): [True: 0, False: 2.15k] ------------------ 1101| 0| dl_total_time = INT_MAX - 1; 1102| 2.15k| else if (dl_total_time < 0) ------------------ | Branch (1102:12): [True: 0, False: 2.15k] ------------------ 1103| 0| dl_total_time = 0; 1104| | 1105| 2.15k| if (orig_filename_cols < MAX_FILENAME_COLS) ------------------ | Branch (1105:7): [True: 1.95k, False: 198] ------------------ 1106| 1.95k| { 1107| 1.95k| p += sprintf (p, "%s", bp->f_download); 1108| 1.95k| padding = MAX_FILENAME_COLS - orig_filename_cols + 1; 1109| 1.95k| memset (p, ' ', padding); 1110| 1.95k| p += padding; 1111| 1.95k| } 1112| 198| else 1113| 198| { 1114| |/* 1115| | memcpy(p, bp->f_download, MAX_FILENAME_COLS); 1116| | p += MAX_FILENAME_COLS; 1117| | *p++ = ' '; 1118| | } 1119| |*/ 1120| 198| int offset_cols; 1121| 198| int bytes_in_filename, offset_bytes, col; 1122| 198| int *cols_ret = &col; 1123| | 1124| 198|#define MIN_SCROLL_TEXT 5 1125| 198| if ((orig_filename_cols > MAX_FILENAME_COLS + MIN_SCROLL_TEXT) && ------------------ | | 1124| 198|#define MIN_SCROLL_TEXT 5 ------------------ | Branch (1125:11): [True: 153, False: 45] ------------------ 1126| 198| !opt.noscroll && ------------------ | Branch (1126:11): [True: 153, False: 0] ------------------ 1127| 198| !done) ------------------ | Branch (1127:11): [True: 91, False: 62] ------------------ 1128| 91| { 1129| 91| offset_cols = ((int) bp->tick + orig_filename_cols + MAX_FILENAME_COLS / 2) 1130| 91| % (orig_filename_cols + MAX_FILENAME_COLS); 1131| 91| if (offset_cols > orig_filename_cols) ------------------ | Branch (1131:15): [True: 91, False: 0] ------------------ 1132| 91| { 1133| 91| padding = MAX_FILENAME_COLS - (offset_cols - orig_filename_cols); 1134| 91| memset(p, ' ', padding); 1135| 91| p += padding; 1136| 91| offset_cols = 0; 1137| 91| } 1138| 0| else 1139| 0| padding = 0; 1140| 91| } 1141| 107| else 1142| 107| { 1143| 107| padding = 0; 1144| 107| offset_cols = 0; 1145| 107| } 1146| 198| offset_bytes = cols_to_bytes (bp->f_download, offset_cols, cols_ret); 1147| 198| bytes_in_filename = cols_to_bytes (bp->f_download + offset_bytes, 1148| 198| MAX_FILENAME_COLS - padding, 1149| 198| cols_ret); 1150| 198| memcpy (p, bp->f_download + offset_bytes, bytes_in_filename); 1151| 198| p += bytes_in_filename; 1152| 198| padding = MAX_FILENAME_COLS - (padding + *cols_ret); 1153| 198| memset (p, ' ', padding + 1); 1154| 198| p += padding + 1; 1155| 198| } 1156| | 1157| | 1158| | /* "xx% " */ 1159| 2.15k| if (bp->total_length > 0) ------------------ | Branch (1159:7): [True: 2.14k, False: 8] ------------------ 1160| 2.14k| { 1161| 2.14k| int percentage = 100.0 * size / bp->total_length; 1162| 2.14k| assert (percentage <= 100); 1163| 2.14k| p += sprintf (p, "%3d%%", percentage); 1164| 2.14k| } 1165| 8| else 1166| 8| { 1167| 8| memset (p, ' ', PROGRESS_PERCENT_LEN); ------------------ | | 1080| 8|#define PROGRESS_PERCENT_LEN 4 ------------------ 1168| 8| p += PROGRESS_PERCENT_LEN; ------------------ | | 1080| 8|#define PROGRESS_PERCENT_LEN 4 ------------------ 1169| 8| } 1170| | 1171| | /* The progress bar: "[====> ]" or "[++==> ]". */ 1172| 2.15k| if (progress_size && bp->total_length > 0) ------------------ | Branch (1172:7): [True: 2.15k, False: 0] | Branch (1172:24): [True: 2.14k, False: 8] ------------------ 1173| 2.14k| { 1174| | /* Size of the initial portion. */ 1175| 2.14k| int insz = (double)bp->initial_length / bp->total_length * progress_size; 1176| | 1177| | /* Size of the downloaded portion. */ 1178| 2.14k| int dlsz = (double)size / bp->total_length * progress_size; 1179| | 1180| 2.14k| char *begin; 1181| | 1182| 2.14k| assert (dlsz <= progress_size); 1183| 2.14k| assert (insz <= dlsz); 1184| | 1185| 2.14k| *p++ = '['; 1186| 2.14k| begin = p; 1187| | 1188| | /* Print the initial portion of the download with '+' chars, the 1189| | rest with '=' and one '>'. */ 1190| 2.14k| memset (p, '+', insz); 1191| 2.14k| p += insz; 1192| | 1193| 2.14k| dlsz -= insz; 1194| 2.14k| if (dlsz > 0) ------------------ | Branch (1194:11): [True: 773, False: 1.37k] ------------------ 1195| 773| { 1196| 773| memset (p, '=', dlsz-1); 1197| 773| p += dlsz - 1; 1198| 773| *p++ = '>'; 1199| 773| } 1200| | 1201| 2.14k| memset (p, ' ', (progress_size - (p - begin))); 1202| 2.14k| p += (progress_size - (p - begin)); 1203| 2.14k| *p++ = ']'; 1204| 2.14k| } 1205| 8| else if (progress_size) ------------------ | Branch (1205:12): [True: 8, False: 0] ------------------ 1206| 8| { 1207| | /* If we can't draw a real progress bar, then at least show 1208| | *something* to the user. */ 1209| 8| int ind = bp->tick % (progress_size * 2 - 6); 1210| 8| int i, pos; 1211| | 1212| | /* Make the star move in two directions. */ 1213| 8| if (ind < progress_size - 2) ------------------ | Branch (1213:11): [True: 8, False: 0] ------------------ 1214| 8| pos = ind + 1; 1215| 0| else 1216| 0| pos = progress_size - (ind - progress_size + 5); 1217| | 1218| 8| *p++ = '['; 1219| 168| for (i = 0; i < progress_size; i++) ------------------ | Branch (1219:19): [True: 160, False: 8] ------------------ 1220| 160| { 1221| 160| if (i == pos - 1) *p++ = '<'; ------------------ | Branch (1221:20): [True: 8, False: 152] ------------------ 1222| 152| else if (i == pos ) *p++ = '='; ------------------ | Branch (1222:20): [True: 8, False: 144] ------------------ 1223| 144| else if (i == pos + 1) *p++ = '>'; ------------------ | Branch (1223:20): [True: 8, False: 136] ------------------ 1224| 136| else 1225| 136| *p++ = ' '; 1226| 160| } 1227| 8| *p++ = ']'; 1228| | 1229| 8| } 1230| 2.15k| ++bp->tick; 1231| | 1232| | /* " 234.56M" */ 1233| 2.15k| down_size = human_readable (size, 1000, 2); 1234| 2.15k| cols_diff = PROGRESS_FILESIZE_LEN - count_cols (down_size); ------------------ | | 1082| 2.15k|#define PROGRESS_FILESIZE_LEN 7 + 1 ------------------ 1235| 2.15k| if (cols_diff > 0) ------------------ | Branch (1235:7): [True: 2.15k, False: 0] ------------------ 1236| 2.15k| { 1237| 2.15k| memset (p, ' ', cols_diff); 1238| 2.15k| p += cols_diff; 1239| 2.15k| } 1240| 2.15k| p += sprintf (p, "%s", down_size); 1241| | 1242| | /* " 12.52Kb/s or 12.52KB/s" */ 1243| 2.15k| if (hist->total_time > 0 && hist->total_bytes) ------------------ | Branch (1243:7): [True: 579, False: 1.57k] | Branch (1243:31): [True: 579, False: 0] ------------------ 1244| 579| { 1245| 579| static const char *short_units[] = { " B/s", "KB/s", "MB/s", "GB/s", "TB/s" }; 1246| 579| static const char *short_units_bits[] = { " b/s", "Kb/s", "Mb/s", "Gb/s", "Tb/s" }; 1247| 579| int units = 0; 1248| | /* Calculate the download speed using the history ring and 1249| | recent data that hasn't made it to the ring yet. */ 1250| 579| wgint dlquant = hist->total_bytes + bp->recent_bytes; 1251| 579| double dltime = hist->total_time + (dl_total_time - bp->recent_start); 1252| 579| double dlspeed = calc_rate (dlquant, dltime, &units); 1253| 579| p += sprintf (p, " %4.*f%s", dlspeed >= 99.95 ? 0 : dlspeed >= 9.995 ? 1 : 2, ------------------ | Branch (1253:37): [True: 431, False: 148] | Branch (1253:60): [True: 77, False: 71] ------------------ 1254| 579| dlspeed, !opt.report_bps ? short_units[units] : short_units_bits[units]); ------------------ | Branch (1254:26): [True: 579, False: 0] ------------------ 1255| 579| } 1256| 1.57k| else 1257| 1.57k| APPEND_LITERAL (" --.-KB/s"); ------------------ | | 1038| 1.57k|#define APPEND_LITERAL(s) do { \ | | 1039| 1.57k| memcpy (p, s, sizeof (s) - 1); \ | | 1040| 1.57k| p += sizeof (s) - 1; \ | | 1041| 1.57k|} while (0) | | ------------------ | | | Branch (1041:10): [Folded - Ignored] | | ------------------ ------------------ 1258| | 1259| 2.15k| if (!done) ------------------ | Branch (1259:7): [True: 1.36k, False: 786] ------------------ 1260| 1.36k| { 1261| | /* " eta ..m ..s"; wait for three seconds before displaying the ETA. 1262| | That's because the ETA value needs a while to become 1263| | reliable. */ 1264| 1.36k| if (bp->total_length > 0 && bp->count > 0 && dl_total_time > 3) ------------------ | Branch (1264:11): [True: 1.36k, False: 5] | Branch (1264:35): [True: 0, False: 1.36k] | Branch (1264:52): [True: 0, False: 0] ------------------ 1265| 0| { 1266| 0| int eta; 1267| | 1268| | /* Don't change the value of ETA more than approximately once 1269| | per second; doing so would cause flashing without providing 1270| | any value to the user. */ 1271| 0| if (bp->total_length != size ------------------ | Branch (1271:15): [True: 0, False: 0] ------------------ 1272| 0| && bp->last_eta_value != 0 ------------------ | Branch (1272:18): [True: 0, False: 0] ------------------ 1273| 0| && dl_total_time - bp->last_eta_time < ETA_REFRESH_INTERVAL) ------------------ | | 588| 0|#define ETA_REFRESH_INTERVAL 0.99 ------------------ | Branch (1273:18): [True: 0, False: 0] ------------------ 1274| 0| eta = bp->last_eta_value; 1275| 0| else 1276| 0| { 1277| | /* Calculate ETA using the average download speed to predict 1278| | the future speed. If you want to use a speed averaged 1279| | over a more recent period, replace dl_total_time with 1280| | hist->total_time and bp->count with hist->total_bytes. 1281| | I found that doing that results in a very jerky and 1282| | ultimately unreliable ETA. */ 1283| 0| wgint bytes_remaining = bp->total_length - size; 1284| 0| double eta_ = dl_total_time * bytes_remaining / bp->count; 1285| 0| if (eta_ >= INT_MAX - 1) ------------------ | Branch (1285:19): [True: 0, False: 0] ------------------ 1286| 0| goto skip_eta; 1287| 0| eta = (int) (eta_ + 0.5); 1288| 0| bp->last_eta_value = eta; 1289| 0| bp->last_eta_time = dl_total_time; 1290| 0| } 1291| | 1292| 0| p += sprintf (p, get_eta(&bytes_cols_diff), 1293| 0| eta_to_human_short (eta, false)); 1294| 0| } 1295| 1.36k| else if (bp->total_length > 0) ------------------ | Branch (1295:16): [True: 1.36k, False: 5] ------------------ 1296| 1.36k| { 1297| 1.36k| skip_eta: 1298| 1.36k| memset (p, ' ', PROGRESS_ETA_LEN); ------------------ | | 1084| 1.36k|#define PROGRESS_ETA_LEN 15 ------------------ 1299| 1.36k| p += PROGRESS_ETA_LEN; ------------------ | | 1084| 1.36k|#define PROGRESS_ETA_LEN 15 ------------------ 1300| 1.36k| } 1301| 1.36k| } 1302| 786| else 1303| 786| { 1304| | /* When the download is done, print the elapsed time. */ 1305| 786| int nbytes; 1306| 786| int ncols; 1307| | 1308| | /* TRANSLATORS: The meaning is "elapsed time", and it is shown 1309| | * next to the progress bar once the download is done. 1310| | * This should not take up more room than 1311| | * available here (6 columns). Abbreviate if necessary. */ 1312| 786| strcpy (p, _(" in ")); ------------------ | | 64| 786|#define _(STRING) gettext(STRING) ------------------ 1313| 786| nbytes = strlen (p); 1314| 786| ncols = count_cols (p); 1315| 786| bytes_cols_diff = nbytes - ncols; 1316| 786| if (dl_total_time >= 10) ------------------ | Branch (1316:11): [True: 574, False: 212] ------------------ 1317| 574| ncols += sprintf (p + nbytes, "%s", eta_to_human_short ((int) (dl_total_time + 0.5), false)); 1318| 212| else 1319| 212| ncols += sprintf (p + nbytes, "%ss", print_decimal (dl_total_time)); 1320| 786| p += ncols + bytes_cols_diff; 1321| 786| if (ncols < PROGRESS_ETA_LEN) ------------------ | | 1084| 786|#define PROGRESS_ETA_LEN 15 ------------------ | Branch (1321:11): [True: 786, False: 0] ------------------ 1322| 786| { 1323| 786| memset (p, ' ', PROGRESS_ETA_LEN - ncols); ------------------ | | 1084| 786|#define PROGRESS_ETA_LEN 15 ------------------ 1324| 786| p += PROGRESS_ETA_LEN - ncols; ------------------ | | 1084| 786|#define PROGRESS_ETA_LEN 15 ------------------ 1325| 786| } 1326| 786| } 1327| | 1328| 2.15k| *p = '\0'; 1329| | 1330| 2.15k| padding = bp->width - count_cols (bp->buffer); 1331| 2.15k| assert (padding >= 0 && "Padding length became non-positive!"); 1332| 2.15k| if (padding > 0) ------------------ | Branch (1332:7): [True: 5, False: 2.15k] ------------------ 1333| 5| { 1334| |// if (padding > BUF_LEN - (p - bp->buffer) - 1) 1335| |// padding = BUF_LEN - (p - bp->buffer) - 1; 1336| 5| memset (p, ' ', padding); 1337| 5| p += padding; 1338| 5| *p = '\0'; 1339| 5| } 1340| | 1341| | /* 2014-11-14 Darshit Shah 1342| | * Assert that the length of the progress bar is lesser than the size of the 1343| | * screen with which we are dealing. This assertion *MUST* always be removed 1344| | * from the release code since we do not want Wget to crash and burn when the 1345| | * assertion fails. Instead Wget should continue downloading and display a 1346| | * horrible and irritating progress bar that spams the screen with newlines. 1347| | * 1348| | * By default, all assertions are disabled in a Wget build and are enabled 1349| | * only with the --enable-assert configure option. 1350| | */ 1351| 2.15k| assert (count_cols (bp->buffer) == bp->width); 1352| 2.15k|} progress.c:count_cols: 950| 7.25k|{ 951| 7.25k| mbchar_t mbc; 952| 7.25k| mbi_iterator_t iter; 953| 7.25k| int cols = 0; 954| 7.25k| mbi_init (iter, mbs, strlen(mbs)); ------------------ | | 197| 7.25k| ((iter).cur.ptr = (startptr), (iter).limit = (iter).cur.ptr + (length), \ | | 198| 7.25k| (iter).in_shift = false, memset (&(iter).state, '\0', sizeof (mbstate_t)), \ | | 199| 7.25k| (iter).next_done = false) ------------------ 955| 350k| while (mbi_avail (iter)) ------------------ | | 201| 350k| ((iter).cur.ptr < (iter).limit && (mbiter_multi_next (&(iter)), true)) | | ------------------ | | | Branch (201:4): [True: 343k, False: 7.25k] | | | Branch (201:37): [True: 343k, False: 0] | | ------------------ ------------------ 956| 343k| { 957| 343k| mbc = mbi_cur (iter); ------------------ | | 206| 343k|#define mbi_cur(iter) (iter).cur ------------------ 958| 343k| cols += mb_width (mbc); ------------------ | | 248| 343k| ((mbc).wc_valid ? mb_width_aux ((mbc).wc) : MB_UNPRINTABLE_WIDTH) | | ------------------ | | | | 236| 0|#define MB_UNPRINTABLE_WIDTH 1 | | ------------------ | | | Branch (248:4): [True: 343k, False: 0] | | ------------------ ------------------ 959| 343k| mbi_advance (iter); ------------------ | | 203| 343k| ((iter).cur.ptr += (iter).cur.bytes, (iter).next_done = false) ------------------ 960| 343k| } 961| 7.25k| return cols; 962| 7.25k|} progress.c:cols_to_bytes: 966| 396|{ 967| 396| int p_cols = 0, bytes = 0; 968| 396| mbchar_t mbc; 969| 396| mbi_iterator_t iter; 970| 396| mbi_init (iter, mbs, strlen(mbs)); ------------------ | | 197| 396| ((iter).cur.ptr = (startptr), (iter).limit = (iter).cur.ptr + (length), \ | | 198| 396| (iter).in_shift = false, memset (&(iter).state, '\0', sizeof (mbstate_t)), \ | | 199| 396| (iter).next_done = false) ------------------ 971| 3.27k| while (p_cols < cols && mbi_avail (iter)) ------------------ | | 201| 2.88k| ((iter).cur.ptr < (iter).limit && (mbiter_multi_next (&(iter)), true)) | | ------------------ | | | Branch (201:4): [True: 2.88k, False: 0] | | | Branch (201:37): [True: 2.88k, False: 0] | | ------------------ ------------------ | Branch (971:10): [True: 2.88k, False: 396] ------------------ 972| 2.88k| { 973| 2.88k| mbc = mbi_cur (iter); ------------------ | | 206| 2.88k|#define mbi_cur(iter) (iter).cur ------------------ 974| 2.88k| p_cols += mb_width (mbc); ------------------ | | 248| 2.88k| ((mbc).wc_valid ? mb_width_aux ((mbc).wc) : MB_UNPRINTABLE_WIDTH) | | ------------------ | | | | 236| 0|#define MB_UNPRINTABLE_WIDTH 1 | | ------------------ | | | Branch (248:4): [True: 2.88k, False: 0] | | ------------------ ------------------ 975| | /* The multibyte character has exceeded the total number of columns we 976| | * have available. The remaining bytes will be padded with a space. */ 977| 2.88k| if (p_cols > cols) ------------------ | Branch (977:11): [True: 0, False: 2.88k] ------------------ 978| 0| { 979| 0| p_cols -= mb_width (mbc); ------------------ | | 248| 0| ((mbc).wc_valid ? mb_width_aux ((mbc).wc) : MB_UNPRINTABLE_WIDTH) | | ------------------ | | | | 236| 0|#define MB_UNPRINTABLE_WIDTH 1 | | ------------------ | | | Branch (248:4): [True: 0, False: 0] | | ------------------ ------------------ 980| 0| break; 981| 0| } 982| 2.88k| bytes += mb_len (mbc); ------------------ | | 177| 2.88k|#define mb_len(mbc) ((mbc).bytes) ------------------ 983| 2.88k| mbi_advance (iter); ------------------ | | 203| 2.88k| ((iter).cur.ptr += (iter).cur.bytes, (iter).next_done = false) ------------------ 984| 2.88k| } 985| 396| *ncols = p_cols; 986| 396| return bytes; 987| 396|} progress.c:display_image: 1359| 2.15k|{ 1360| 2.15k| bool old = log_set_save_context (false); 1361| 2.15k| logputs (LOG_PROGRESS, "\r"); 1362| 2.15k| logputs (LOG_PROGRESS, buf); 1363| 2.15k| log_set_save_context (old); 1364| 2.15k|} progress.c:bar_update: 763| 1.57k|{ 764| 1.57k| struct bar_progress *bp = progress; 765| | 766| 1.57k| bp->dltime = dltime; 767| 1.57k| if (WGINT_MAX - (bp->count + bp->initial_length) >= howmuch) ------------------ | | 145| 1.57k|#define WGINT_MAX INT64_MAX ------------------ | Branch (767:7): [True: 1.57k, False: 0] ------------------ 768| 1.57k| bp->count += howmuch; 769| 0| else 770| 0| bp->count = WGINT_MAX - bp->initial_length; ------------------ | | 145| 0|#define WGINT_MAX INT64_MAX ------------------ 771| 1.57k| if (bp->total_length > 0 ------------------ | Branch (771:7): [True: 1.56k, False: 6] ------------------ 772| 1.57k| && bp->count + bp->initial_length > bp->total_length) ------------------ | Branch (772:10): [True: 0, False: 1.56k] ------------------ 773| | /* We could be downloading more than total_length, e.g. when the 774| | server sends an incorrect Content-Length header. In that case, 775| | adjust bp->total_length to the new reality, so that the code in 776| | create_image() that depends on total size being smaller or 777| | equal to the expected size doesn't abort. */ 778| 0| bp->total_length = bp->initial_length + bp->count; 779| | 780| 1.57k| update_speed_ring (bp, howmuch, dltime); 781| 1.57k|} progress.c:update_speed_ring: 858| 1.57k|{ 859| 1.57k| struct bar_progress_hist *hist = &bp->hist; 860| 1.57k| double recent_age = dltime - bp->recent_start; 861| | 862| | /* Update the download count. */ 863| 1.57k| bp->recent_bytes += howmuch; 864| | 865| | /* For very small time intervals, we return after having updated the 866| | "recent" download count. When its age reaches or exceeds minimum 867| | sample time, it will be recorded in the history ring. */ 868| 1.57k| if (recent_age < DLSPEED_SAMPLE_MIN) ------------------ | | 575| 1.57k|#define DLSPEED_SAMPLE_MIN 0.15 ------------------ | Branch (868:7): [True: 406, False: 1.16k] ------------------ 869| 406| return; 870| | 871| 1.16k| if (howmuch == 0) ------------------ | Branch (871:7): [True: 587, False: 579] ------------------ 872| 587| { 873| | /* If we're not downloading anything, we might be stalling, 874| | i.e. not downloading anything for an extended period of time. 875| | Since 0-reads do not enter the history ring, recent_age 876| | effectively measures the time since last read. */ 877| 587| if (recent_age >= STALL_START_TIME) ------------------ | | 580| 587|#define STALL_START_TIME 5 ------------------ | Branch (877:11): [True: 580, False: 7] ------------------ 878| 580| { 879| | /* If we're stalling, reset the ring contents because it's 880| | stale and because it will make bar_update stop printing 881| | the (bogus) current bandwidth. */ 882| 580| bp->stalled = true; 883| 580| xzero (*hist); ------------------ | | 178| 580|#define xzero(x) memset (&(x), '\0', sizeof (x)) ------------------ 884| 580| bp->recent_bytes = 0; 885| 580| } 886| 587| return; 887| 587| } 888| | 889| | /* We now have a non-zero amount of to store to the speed ring. */ 890| | 891| | /* If the stall status was acquired, reset it. */ 892| 579| if (bp->stalled) ------------------ | Branch (892:7): [True: 574, False: 5] ------------------ 893| 574| { 894| 574| bp->stalled = false; 895| | /* "recent_age" includes the entire stalled period, which 896| | could be very long. Don't update the speed ring with that 897| | value because the current bandwidth would start too small. 898| | Start with an arbitrary (but more reasonable) time value and 899| | let it level out. */ 900| 574| recent_age = 1; 901| 574| } 902| | 903| | /* Store "recent" bytes and download time to history ring at the 904| | position POS. */ 905| | 906| | /* To correctly maintain the totals, first invalidate existing data 907| | (least recent in time) at this position. */ 908| 579| hist->total_time -= hist->times[hist->pos]; 909| 579| hist->total_bytes -= hist->bytes[hist->pos]; 910| | 911| | /* Now store the new data and update the totals. */ 912| 579| hist->times[hist->pos] = recent_age; 913| 579| hist->bytes[hist->pos] = bp->recent_bytes; 914| 579| hist->total_time += recent_age; 915| 579| hist->total_bytes += bp->recent_bytes; 916| | 917| | /* Start a new "recent" period. */ 918| 579| bp->recent_start = dltime; 919| 579| bp->recent_bytes = 0; 920| | 921| | /* Advance the current ring position. */ 922| 579| if (++hist->pos == DLSPEED_HISTORY_SIZE) ------------------ | | 569| 579|#define DLSPEED_HISTORY_SIZE 20 ------------------ | Branch (922:7): [True: 0, False: 579] ------------------ 923| 0| hist->pos = 0; 924| | 925| |#if 0 926| | /* Sledgehammer check to verify that the totals are accurate. */ 927| | { 928| | int i; 929| | double sumt = 0, sumb = 0; 930| | for (i = 0; i < DLSPEED_HISTORY_SIZE; i++) 931| | { 932| | sumt += hist->times[i]; 933| | sumb += hist->bytes[i]; 934| | } 935| | assert (sumb == hist->total_bytes); 936| | /* We can't use assert(sumt==hist->total_time) because some 937| | precision is lost by adding and subtracting floating-point 938| | numbers. But during a download this precision should not be 939| | detectable, i.e. no larger than 1ns. */ 940| | double diff = sumt - hist->total_time; 941| | if (diff < 0) diff = -diff; 942| | assert (diff < 1e-9); 943| | } 944| |#endif 945| 579|} progress.c:bar_draw: 785| 1.57k|{ 786| 1.57k| bool force_screen_update = false; 787| 1.57k| struct bar_progress *bp = progress; 788| | 789| | /* If SIGWINCH (the window size change signal) been received, 790| | determine the new screen size and update the screen. */ 791| 1.57k| if (received_sigwinch) ------------------ | Branch (791:7): [True: 0, False: 1.57k] ------------------ 792| 0| { 793| 0| int old_width = screen_width; 794| 0| screen_width = determine_screen_width (); 795| 0| if (!screen_width) ------------------ | Branch (795:11): [True: 0, False: 0] ------------------ 796| 0| screen_width = DEFAULT_SCREEN_WIDTH; ------------------ | | 552| 0|#define DEFAULT_SCREEN_WIDTH 80 ------------------ 797| 0| else if (screen_width < MINIMUM_SCREEN_WIDTH) ------------------ | | 558| 0|#define MINIMUM_SCREEN_WIDTH 51 ------------------ | Branch (797:16): [True: 0, False: 0] ------------------ 798| 0| screen_width = MINIMUM_SCREEN_WIDTH; ------------------ | | 558| 0|#define MINIMUM_SCREEN_WIDTH 51 ------------------ 799| 0| if (screen_width != old_width) ------------------ | Branch (799:11): [True: 0, False: 0] ------------------ 800| 0| { 801| 0| bp->width = screen_width - 1; 802| 0| bp->buffer = xrealloc (bp->buffer, BUF_LEN); ------------------ | | 748| 0|#define BUF_LEN (bp->width * 2 + 100) ------------------ 803| 0| force_screen_update = true; 804| 0| } 805| 0| received_sigwinch = 0; 806| 0| } 807| | 808| 1.57k| if (bp->dltime - bp->last_screen_update < REFRESH_INTERVAL && !force_screen_update) ------------------ | | 584| 3.14k|#define REFRESH_INTERVAL 0.2 ------------------ | Branch (808:7): [True: 989, False: 583] | Branch (808:65): [True: 989, False: 0] ------------------ 809| | /* Don't update more often than five times per second. */ 810| 989| return; 811| | 812| 583| create_image (bp, bp->dltime, false); 813| 583| display_image (bp->buffer); 814| 583| bp->last_screen_update = bp->dltime; 815| 583|} progress.c:bar_finish: 819| 786|{ 820| 786| struct bar_progress *bp = progress; 821| | 822| 786| if (bp->total_length > 0 ------------------ | Branch (822:7): [True: 783, False: 3] ------------------ 823| 786| && bp->count + bp->initial_length > bp->total_length) ------------------ | Branch (823:10): [True: 0, False: 783] ------------------ 824| | /* See bar_update() for explanation. */ 825| 0| bp->total_length = bp->initial_length + bp->count; 826| | 827| 786| create_image (bp, dltime, true); 828| 786| display_image (bp->buffer); 829| | 830| 786| logputs (LOG_VERBOSE, "\n"); 831| 786| logputs (LOG_PROGRESS, "\n"); 832| | 833| 786| xfree (bp->f_download); ------------------ | | 54| 786|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 834| 786| xfree (bp->buffer); ------------------ | | 54| 786|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 835| 786| xfree (bp); ------------------ | | 54| 786|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 836| 786|} progress.c:bar_set_params: 1368| 786|{ 1369| |/* if run_with_timeout() will be used for read, needs to disable interactive bar, 1370| | or on every timeout(1s) we will have 'retry' with error "decryption failed" */ 1371| |#if (defined(HAVE_LIBSSL) || defined(HAVE_LIBSSL32)) && defined(OPENSSL_RUN_WITHTIMEOUT) 1372| | current_impl->interactive = false; 1373| |#else 1374| 786| current_impl->interactive = true; 1375| 786|#endif 1376| 786| if (params) ------------------ | Branch (1376:7): [True: 786, False: 0] ------------------ 1377| 786| { 1378| 1.57k| for (const char *param = params; *param; ) ------------------ | Branch (1378:40): [True: 786, False: 786] ------------------ 1379| 786| { 1380| 786| if (!strncmp (param, "force", 5)) ------------------ | Branch (1380:15): [True: 786, False: 0] ------------------ 1381| 786| current_impl_locked = 1; 1382| 0| else if (!strncmp (param, "noscroll", 8)) ------------------ | Branch (1382:20): [True: 0, False: 0] ------------------ 1383| 0| opt.noscroll = true; 1384| | 1385| 786| if (*(param = strchrnul(param, ':'))) ------------------ | Branch (1385:15): [True: 0, False: 786] ------------------ 1386| 0| param++; 1387| 786| } 1388| 786| } 1389| | 1390| 786| if (((opt.lfilename && opt.show_progress != 1) ------------------ | Branch (1390:9): [True: 0, False: 786] | Branch (1390:26): [True: 0, False: 0] ------------------ 1391| 786|#ifdef HAVE_ISATTY 1392| | /* The progress bar doesn't make sense if the output is not a 1393| | TTY -- when logging to file, it is better to review the 1394| | dots. */ 1395| 786| || !isatty (fileno (stderr)) ------------------ | Branch (1395:11): [True: 786, False: 0] ------------------ 1396| 786|#endif 1397| 786| ) 1398| 786| && !current_impl_locked) ------------------ | Branch (1398:10): [True: 0, False: 786] ------------------ 1399| 0| { 1400| | /* We're not printing to a TTY, so revert to the fallback 1401| | display. #### We're recursively calling 1402| | set_progress_implementation here, which is slightly kludgy. 1403| | It would be nicer if we provided that function a return value 1404| | indicating a failure of some sort. */ 1405| 0| set_progress_implementation (FALLBACK_PROGRESS_IMPLEMENTATION); ------------------ | | 89| 0|#define FALLBACK_PROGRESS_IMPLEMENTATION "dot" ------------------ 1406| 0| return; 1407| 0| } 1408| 786|} ptimer_resolution: 411| 3.82k|{ 412| 3.82k| return IMPL_resolution (); ------------------ | | 102| 3.82k|#define IMPL_resolution posix_resolution ------------------ 413| 3.82k|} ptimer.c:posix_resolution: 181| 3.82k|{ 182| 3.82k| return posix_clock_resolution; 183| 3.82k|} calc_rate: 803| 6.73k|{ 804| 6.73k| double dlrate; 805| 6.73k| double bibyte; 806| | 807| 6.73k| if (!opt.report_bps) ------------------ | Branch (807:7): [True: 6.73k, False: 0] ------------------ 808| 6.73k| bibyte = 1024.0; 809| 0| else 810| 0| bibyte = 1000.0; 811| | 812| 6.73k| if (secs == 0) ------------------ | Branch (812:7): [True: 3.82k, False: 2.91k] ------------------ 813| | /* If elapsed time is exactly zero, it means we're under the 814| | resolution of the timer. This can easily happen on systems 815| | that use time() for the timer. Since the interval lies between 816| | 0 and the timer's resolution, assume half the resolution. */ 817| 3.82k| secs = ptimer_resolution () / 2.0; 818| | 819| 6.73k| dlrate = secs ? convert_to_bits (bytes) / secs : 0; ------------------ | Branch (819:12): [True: 2.91k, False: 3.82k] ------------------ 820| 6.73k| if (dlrate < bibyte) ------------------ | Branch (820:7): [True: 4.55k, False: 2.18k] ------------------ 821| 4.55k| *units = 0; 822| 2.18k| else if (dlrate < (bibyte * bibyte)) ------------------ | Branch (822:12): [True: 359, False: 1.82k] ------------------ 823| 359| *units = 1, dlrate /= bibyte; 824| 1.82k| else if (dlrate < (bibyte * bibyte * bibyte)) ------------------ | Branch (824:12): [True: 579, False: 1.24k] ------------------ 825| 579| *units = 2, dlrate /= (bibyte * bibyte); 826| 1.24k| else if (dlrate < (bibyte * bibyte * bibyte * bibyte)) ------------------ | Branch (826:12): [True: 786, False: 459] ------------------ 827| 786| *units = 3, dlrate /= (bibyte * bibyte * bibyte); 828| 459| else { 829| 459| *units = 4, dlrate /= (bibyte * bibyte * bibyte * bibyte); 830| 459| if (dlrate > 99.99) ------------------ | Branch (830:9): [True: 389, False: 70] ------------------ 831| 389| dlrate = 99.99; // upper limit 99.99TB/s 832| 459| } 833| | 834| 6.73k| return dlrate; 835| 6.73k|} human_readable: 1677| 2.15k|{ 1678| | /* These suffixes are compatible with those of GNU `ls -lh'. */ 1679| 2.15k| static char powers[] = 1680| 2.15k| { 1681| 2.15k| 'K', /* kilobyte, 2^10 bytes */ 1682| 2.15k| 'M', /* megabyte, 2^20 bytes */ 1683| 2.15k| 'G', /* gigabyte, 2^30 bytes */ 1684| 2.15k| 'T', /* terabyte, 2^40 bytes */ 1685| 2.15k| 'P', /* petabyte, 2^50 bytes */ 1686| 2.15k| 'E', /* exabyte, 2^60 bytes */ 1687| 2.15k| }; 1688| 2.15k| static char buf[8]; 1689| 2.15k| size_t i; 1690| | 1691| | /* If the quantity is smaller than 1K, just print it. */ 1692| 2.15k| if (n < 1024) ------------------ | Branch (1692:7): [True: 171, False: 1.98k] ------------------ 1693| 171| { 1694| 171| snprintf (buf, sizeof (buf), "%d", (int) n); 1695| 171| return buf; 1696| 171| } 1697| | 1698| | /* Loop over powers, dividing N with 1024 in each iteration. This 1699| | works unchanged for all sizes of wgint, while still avoiding 1700| | non-portable `long double' arithmetic. */ 1701| 8.17k| for (i = 0; i < countof (powers); i++) ------------------ | | 175| 8.17k|#define countof(array) (sizeof (array) / sizeof ((array)[0])) ------------------ | Branch (1701:15): [True: 8.17k, False: 0] ------------------ 1702| 8.17k| { 1703| | /* At each iteration N is greater than the *subsequent* power. 1704| | That way N/1024.0 produces a decimal number in the units of 1705| | *this* power. */ 1706| 8.17k| if ((n / 1024) < 1024 || i == countof (powers) - 1) ------------------ | | 175| 6.19k|#define countof(array) (sizeof (array) / sizeof ((array)[0])) ------------------ | Branch (1706:11): [True: 1.98k, False: 6.19k] | Branch (1706:32): [True: 0, False: 6.19k] ------------------ 1707| 1.98k| { 1708| 1.98k| double val = n / 1024.0; 1709| | /* Print values smaller than the accuracy level (acc) with (decimal) 1710| | * decimal digits, and others without any decimals. */ 1711| 1.98k| snprintf (buf, sizeof (buf), "%.*f%c", 1712| 1.98k| val < acc ? decimals : 0, val, powers[i]); ------------------ | Branch (1712:21): [True: 1.93k, False: 47] ------------------ 1713| 1.98k| return buf; 1714| 1.98k| } 1715| 6.19k| n /= 1024; 1716| 6.19k| } 1717| 0| return NULL; /* unreached */ 1718| 1.98k|} numdigit: 1725| 2.41k|{ 1726| 2.41k| int cnt = 1; 1727| 2.41k| if (number < 0) ------------------ | Branch (1727:7): [True: 0, False: 2.41k] ------------------ 1728| 0| ++cnt; /* accommodate '-' */ 1729| 27.3k| while ((number /= 10) != 0) ------------------ | Branch (1729:10): [True: 24.9k, False: 2.41k] ------------------ 1730| 24.9k| ++cnt; 1731| 2.41k| return cnt; 1732| 2.41k|} number_to_string: 1788| 9.20k|{ 1789| 9.20k| char *p = buffer; 1790| 9.20k| wgint n = number; 1791| | 1792| 9.20k| int last_digit_char = 0; 1793| | 1794| 9.20k| if (n < 0) ------------------ | Branch (1794:7): [True: 0, False: 9.20k] ------------------ 1795| 0| { 1796| 0| if (n < -WGINT_MAX) ------------------ | | 145| 0|#define WGINT_MAX INT64_MAX ------------------ | Branch (1796:11): [True: 0, False: 0] ------------------ 1797| 0| { 1798| | /* n = -n would overflow because -n would evaluate to a 1799| | wgint value larger than WGINT_MAX. Need to make n 1800| | smaller and handle the last digit separately. */ 1801| 0| int last_digit = n % 10; 1802| | /* The sign of n%10 is implementation-defined. */ 1803| 0| if (last_digit < 0) ------------------ | Branch (1803:15): [True: 0, False: 0] ------------------ 1804| 0| last_digit_char = '0' - last_digit; 1805| 0| else 1806| 0| last_digit_char = '0' + last_digit; 1807| | /* After n is made smaller, -n will not overflow. */ 1808| 0| n /= 10; 1809| 0| } 1810| | 1811| 0| *p++ = '-'; 1812| 0| n = -n; 1813| 0| } 1814| | 1815| | /* Use the DIGITS_ macro appropriate for N's number of digits. That 1816| | way printing any N is fully open-coded without a loop or jump. 1817| | (Also see description of DIGITS_*.) */ 1818| | 1819| 9.20k| if (n < 10) DIGITS_1 (1); ------------------ | | 1741| 1.07k|#define DIGITS_1(mask) PR (mask) | | ------------------ | | | | 1734| 1.07k|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ ------------------ | Branch (1819:12): [True: 1.07k, False: 8.13k] ------------------ 1820| 8.13k| else if (n < 100) DIGITS_2 (10); ------------------ | | 1742| 60|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | ------------------ | | | | 1734| 60|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | ------------------ | | | | 1741| 60|#define DIGITS_1(mask) PR (mask) | | | | ------------------ | | | | | | 1734| 60|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | ------------------ ------------------ | Branch (1820:12): [True: 60, False: 8.07k] ------------------ 1821| 8.07k| else if (n < 1000) DIGITS_3 (100); ------------------ | | 1743| 178|#define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | ------------------ | | | | 1734| 178|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | ------------------ | | | | 1742| 178|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | ------------------ | | | | | | 1734| 178|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | ------------------ | | | | | | 1741| 178|#define DIGITS_1(mask) PR (mask) | | | | | | ------------------ | | | | | | | | 1734| 178|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1821:12): [True: 178, False: 7.89k] ------------------ 1822| 7.89k| else if (n < 10000) DIGITS_4 (1000); ------------------ | | 1744| 241|#define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | ------------------ | | | | 1734| 241|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | ------------------ | | | | 1743| 241|#define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | ------------------ | | | | | | 1734| 241|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | | | #define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | ------------------ | | | | | | 1742| 241|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1734| 241|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | ------------------ | | | | | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1741| 241|#define DIGITS_1(mask) PR (mask) | | | | | | | | ------------------ | | | | | | | | | | 1734| 241|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1822:12): [True: 241, False: 7.65k] ------------------ 1823| 7.65k| else if (n < 100000) DIGITS_5 (10000); ------------------ | | 1745| 311|#define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | ------------------ | | | | 1734| 311|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | ------------------ | | | | 1744| 311|#define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | ------------------ | | | | | | 1734| 311|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | | | #define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | ------------------ | | | | | | 1743| 311|#define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1734| 311|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | ------------------ | | | | | | #define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1742| 311|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1734| 311|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | ------------------ | | | | | | | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1741| 311|#define DIGITS_1(mask) PR (mask) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1734| 311|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1823:12): [True: 311, False: 7.34k] ------------------ 1824| 7.34k| else if (n < 1000000) DIGITS_6 (100000); ------------------ | | 1746| 338|#define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | ------------------ | | | | 1734| 338|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | ------------------ | | | | 1745| 338|#define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | ------------------ | | | | | | 1734| 338|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | | | #define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | ------------------ | | | | | | 1744| 338|#define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1734| 338|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | ------------------ | | | | | | #define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1743| 338|#define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1734| 338|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | ------------------ | | | | | | | | #define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1742| 338|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1734| 338|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | ------------------ | | | | | | | | | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1741| 338|#define DIGITS_1(mask) PR (mask) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1734| 338|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1824:12): [True: 338, False: 7.00k] ------------------ 1825| 7.00k| else if (n < 10000000) DIGITS_7 (1000000); ------------------ | | 1747| 368|#define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | ------------------ | | | | 1734| 368|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | ------------------ | | | | 1746| 368|#define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | ------------------ | | | | | | 1734| 368|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | | | #define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | ------------------ | | | | | | 1745| 368|#define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1734| 368|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | ------------------ | | | | | | #define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1744| 368|#define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1734| 368|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | ------------------ | | | | | | | | #define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1743| 368|#define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1734| 368|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | ------------------ | | | | | | | | | | #define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1742| 368|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1734| 368|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1741| 368|#define DIGITS_1(mask) PR (mask) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1734| 368|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1825:12): [True: 368, False: 6.63k] ------------------ 1826| 6.63k| else if (n < 100000000) DIGITS_8 (10000000); ------------------ | | 1748| 310|#define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | ------------------ | | | | 1734| 310|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | ------------------ | | | | 1747| 310|#define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | ------------------ | | | | | | 1734| 310|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | | | #define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | ------------------ | | | | | | 1746| 310|#define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1734| 310|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | ------------------ | | | | | | #define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1745| 310|#define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1734| 310|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | ------------------ | | | | | | | | #define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1744| 310|#define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1734| 310|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | ------------------ | | | | | | | | | | #define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1743| 310|#define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1734| 310|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1742| 310|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1734| 310|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1741| 310|#define DIGITS_1(mask) PR (mask) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1734| 310|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1826:12): [True: 310, False: 6.32k] ------------------ 1827| 6.32k| else if (n < 1000000000) DIGITS_9 (100000000); ------------------ | | 1749| 421|#define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | ------------------ | | | | 1734| 421|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | ------------------ | | | | 1748| 421|#define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | ------------------ | | | | | | 1734| 421|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | | | #define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | ------------------ | | | | | | 1747| 421|#define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1734| 421|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | ------------------ | | | | | | #define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1746| 421|#define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1734| 421|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | ------------------ | | | | | | | | #define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1745| 421|#define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1734| 421|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | ------------------ | | | | | | | | | | #define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1744| 421|#define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1734| 421|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1743| 421|#define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1734| 421|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1742| 421|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1734| 421|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1741| 421|#define DIGITS_1(mask) PR (mask) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1734| 421|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1827:12): [True: 421, False: 5.90k] ------------------ 1828| 5.90k| else if (n < 10*(W)1000000000) DIGITS_10 (1000000000); ------------------ | | 1750| 407|#define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | ------------------ | | | | 1734| 407|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | ------------------ | | | | 1749| 407|#define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | ------------------ | | | | | | 1734| 407|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | | | #define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | ------------------ | | | | | | 1748| 407|#define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1734| 407|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | ------------------ | | | | | | #define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1747| 407|#define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1734| 407|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | ------------------ | | | | | | | | #define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1746| 407|#define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1734| 407|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | ------------------ | | | | | | | | | | #define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1745| 407|#define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1734| 407|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1744| 407|#define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1734| 407|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1743| 407|#define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1734| 407|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | #define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1742| 407|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1734| 407|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1741| 407|#define DIGITS_1(mask) PR (mask) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1734| 407|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1828:12): [True: 407, False: 5.49k] ------------------ 1829| 5.49k| else if (n < 100*(W)1000000000) DIGITS_11 (10*(W)1000000000); ------------------ | | 1754| 513|#define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | ------------------ | | | | 1734| 513|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | ------------------ | | | | 1750| 513|#define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | ------------------ | | | | | | 1734| 513|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | | | #define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | ------------------ | | | | | | 1749| 513|#define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1734| 513|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | ------------------ | | | | | | #define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1748| 513|#define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1734| 513|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | ------------------ | | | | | | | | #define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1747| 513|#define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1734| 513|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | ------------------ | | | | | | | | | | #define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1746| 513|#define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1734| 513|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1745| 513|#define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1734| 513|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1744| 513|#define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1734| 513|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | #define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1743| 513|#define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1734| 513|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | #define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1742| 513|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1734| 513|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1741| 513|#define DIGITS_1(mask) PR (mask) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 1734| 513|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1829:12): [True: 513, False: 4.98k] ------------------ 1830| 4.98k| else if (n < 1000*(W)1000000000) DIGITS_12 (100*(W)1000000000); ------------------ | | 1755| 467|#define DIGITS_12(mask) PR (mask), n %= (mask), DIGITS_11 ((mask) / 10) | | ------------------ | | | | 1734| 467|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_12(mask) PR (mask), n %= (mask), DIGITS_11 ((mask) / 10) | | ------------------ | | | | 1754| 467|#define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | | | ------------------ | | | | | | 1734| 467|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | | | #define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | | | ------------------ | | | | | | 1750| 467|#define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1734| 467|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | ------------------ | | | | | | #define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1749| 467|#define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1734| 467|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | ------------------ | | | | | | | | #define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1748| 467|#define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1734| 467|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | ------------------ | | | | | | | | | | #define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1747| 467|#define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1734| 467|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1746| 467|#define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1734| 467|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1745| 467|#define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1734| 467|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | #define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1744| 467|#define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1734| 467|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | #define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1743| 467|#define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1734| 467|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | #define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1742| 467|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 1734| 467|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 1741| 467|#define DIGITS_1(mask) PR (mask) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 467|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1830:12): [True: 467, False: 4.51k] ------------------ 1831| 4.51k| else if (n < 10000*(W)1000000000) DIGITS_13 (1000*(W)1000000000); ------------------ | | 1756| 472|#define DIGITS_13(mask) PR (mask), n %= (mask), DIGITS_12 ((mask) / 10) | | ------------------ | | | | 1734| 472|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_13(mask) PR (mask), n %= (mask), DIGITS_12 ((mask) / 10) | | ------------------ | | | | 1755| 472|#define DIGITS_12(mask) PR (mask), n %= (mask), DIGITS_11 ((mask) / 10) | | | | ------------------ | | | | | | 1734| 472|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | | | #define DIGITS_12(mask) PR (mask), n %= (mask), DIGITS_11 ((mask) / 10) | | | | ------------------ | | | | | | 1754| 472|#define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1734| 472|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | ------------------ | | | | | | #define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1750| 472|#define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1734| 472|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | ------------------ | | | | | | | | #define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1749| 472|#define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1734| 472|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | ------------------ | | | | | | | | | | #define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1748| 472|#define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1734| 472|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1747| 472|#define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1734| 472|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1746| 472|#define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1734| 472|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | #define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1745| 472|#define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1734| 472|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | #define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1744| 472|#define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1734| 472|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | #define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1743| 472|#define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 1734| 472|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 1742| 472|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 472|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 1741| 472|#define DIGITS_1(mask) PR (mask) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 472|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1831:12): [True: 472, False: 4.04k] ------------------ 1832| 4.04k| else if (n < 100000*(W)1000000000) DIGITS_14 (10000*(W)1000000000); ------------------ | | 1757| 850|#define DIGITS_14(mask) PR (mask), n %= (mask), DIGITS_13 ((mask) / 10) | | ------------------ | | | | 1734| 850|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_14(mask) PR (mask), n %= (mask), DIGITS_13 ((mask) / 10) | | ------------------ | | | | 1756| 850|#define DIGITS_13(mask) PR (mask), n %= (mask), DIGITS_12 ((mask) / 10) | | | | ------------------ | | | | | | 1734| 850|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | | | #define DIGITS_13(mask) PR (mask), n %= (mask), DIGITS_12 ((mask) / 10) | | | | ------------------ | | | | | | 1755| 850|#define DIGITS_12(mask) PR (mask), n %= (mask), DIGITS_11 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1734| 850|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | ------------------ | | | | | | #define DIGITS_12(mask) PR (mask), n %= (mask), DIGITS_11 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1754| 850|#define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1734| 850|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | ------------------ | | | | | | | | #define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1750| 850|#define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1734| 850|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | ------------------ | | | | | | | | | | #define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1749| 850|#define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1734| 850|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1748| 850|#define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1734| 850|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1747| 850|#define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1734| 850|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | #define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1746| 850|#define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1734| 850|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | #define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1745| 850|#define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1734| 850|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | #define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1744| 850|#define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 1734| 850|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 1743| 850|#define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 850|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 1742| 850|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 850|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1741| 850|#define DIGITS_1(mask) PR (mask) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 850|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1832:12): [True: 850, False: 3.19k] ------------------ 1833| 3.19k| else if (n < 1000000*(W)1000000000) DIGITS_15 (100000*(W)1000000000); ------------------ | | 1758| 751|#define DIGITS_15(mask) PR (mask), n %= (mask), DIGITS_14 ((mask) / 10) | | ------------------ | | | | 1734| 751|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_15(mask) PR (mask), n %= (mask), DIGITS_14 ((mask) / 10) | | ------------------ | | | | 1757| 751|#define DIGITS_14(mask) PR (mask), n %= (mask), DIGITS_13 ((mask) / 10) | | | | ------------------ | | | | | | 1734| 751|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | | | #define DIGITS_14(mask) PR (mask), n %= (mask), DIGITS_13 ((mask) / 10) | | | | ------------------ | | | | | | 1756| 751|#define DIGITS_13(mask) PR (mask), n %= (mask), DIGITS_12 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1734| 751|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | ------------------ | | | | | | #define DIGITS_13(mask) PR (mask), n %= (mask), DIGITS_12 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1755| 751|#define DIGITS_12(mask) PR (mask), n %= (mask), DIGITS_11 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1734| 751|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | ------------------ | | | | | | | | #define DIGITS_12(mask) PR (mask), n %= (mask), DIGITS_11 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1754| 751|#define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1734| 751|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | ------------------ | | | | | | | | | | #define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1750| 751|#define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1734| 751|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1749| 751|#define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1734| 751|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1748| 751|#define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1734| 751|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | #define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1747| 751|#define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1734| 751|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | #define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1746| 751|#define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1734| 751|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | #define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1745| 751|#define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 1734| 751|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 1744| 751|#define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 751|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 1743| 751|#define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 751|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1742| 751|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 751|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1741| 751|#define DIGITS_1(mask) PR (mask) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 751|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1833:12): [True: 751, False: 2.44k] ------------------ 1834| 2.44k| else if (n < 10000000*(W)1000000000) DIGITS_16 (1000000*(W)1000000000); ------------------ | | 1759| 2.44k|#define DIGITS_16(mask) PR (mask), n %= (mask), DIGITS_15 ((mask) / 10) | | ------------------ | | | | 1734| 2.44k|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_16(mask) PR (mask), n %= (mask), DIGITS_15 ((mask) / 10) | | ------------------ | | | | 1758| 2.44k|#define DIGITS_15(mask) PR (mask), n %= (mask), DIGITS_14 ((mask) / 10) | | | | ------------------ | | | | | | 1734| 2.44k|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | | | #define DIGITS_15(mask) PR (mask), n %= (mask), DIGITS_14 ((mask) / 10) | | | | ------------------ | | | | | | 1757| 2.44k|#define DIGITS_14(mask) PR (mask), n %= (mask), DIGITS_13 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1734| 2.44k|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | ------------------ | | | | | | #define DIGITS_14(mask) PR (mask), n %= (mask), DIGITS_13 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1756| 2.44k|#define DIGITS_13(mask) PR (mask), n %= (mask), DIGITS_12 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1734| 2.44k|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | ------------------ | | | | | | | | #define DIGITS_13(mask) PR (mask), n %= (mask), DIGITS_12 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1755| 2.44k|#define DIGITS_12(mask) PR (mask), n %= (mask), DIGITS_11 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1734| 2.44k|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | ------------------ | | | | | | | | | | #define DIGITS_12(mask) PR (mask), n %= (mask), DIGITS_11 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1754| 2.44k|#define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1734| 2.44k|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1750| 2.44k|#define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1734| 2.44k|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1749| 2.44k|#define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1734| 2.44k|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | #define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1748| 2.44k|#define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1734| 2.44k|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | #define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1747| 2.44k|#define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1734| 2.44k|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | #define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1746| 2.44k|#define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 1734| 2.44k|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 1745| 2.44k|#define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 2.44k|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 1744| 2.44k|#define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 2.44k|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1743| 2.44k|#define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 2.44k|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1742| 2.44k|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 2.44k|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1741| 2.44k|#define DIGITS_1(mask) PR (mask) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 2.44k|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1834:12): [True: 2.44k, False: 0] ------------------ 1835| 0| else if (n < 100000000*(W)1000000000) DIGITS_17 (10000000*(W)1000000000); ------------------ | | 1760| 0|#define DIGITS_17(mask) PR (mask), n %= (mask), DIGITS_16 ((mask) / 10) | | ------------------ | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_17(mask) PR (mask), n %= (mask), DIGITS_16 ((mask) / 10) | | ------------------ | | | | 1759| 0|#define DIGITS_16(mask) PR (mask), n %= (mask), DIGITS_15 ((mask) / 10) | | | | ------------------ | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | | | #define DIGITS_16(mask) PR (mask), n %= (mask), DIGITS_15 ((mask) / 10) | | | | ------------------ | | | | | | 1758| 0|#define DIGITS_15(mask) PR (mask), n %= (mask), DIGITS_14 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | ------------------ | | | | | | #define DIGITS_15(mask) PR (mask), n %= (mask), DIGITS_14 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1757| 0|#define DIGITS_14(mask) PR (mask), n %= (mask), DIGITS_13 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | ------------------ | | | | | | | | #define DIGITS_14(mask) PR (mask), n %= (mask), DIGITS_13 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1756| 0|#define DIGITS_13(mask) PR (mask), n %= (mask), DIGITS_12 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | ------------------ | | | | | | | | | | #define DIGITS_13(mask) PR (mask), n %= (mask), DIGITS_12 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1755| 0|#define DIGITS_12(mask) PR (mask), n %= (mask), DIGITS_11 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define DIGITS_12(mask) PR (mask), n %= (mask), DIGITS_11 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1754| 0|#define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1750| 0|#define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | #define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1749| 0|#define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | #define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1748| 0|#define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | #define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1747| 0|#define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 1746| 0|#define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 1745| 0|#define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1744| 0|#define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1743| 0|#define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1742| 0|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1741| 0|#define DIGITS_1(mask) PR (mask) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1835:12): [True: 0, False: 0] ------------------ 1836| 0| else if (n < 1000000000*(W)1000000000) DIGITS_18 (100000000*(W)1000000000); ------------------ | | 1761| 0|#define DIGITS_18(mask) PR (mask), n %= (mask), DIGITS_17 ((mask) / 10) | | ------------------ | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_18(mask) PR (mask), n %= (mask), DIGITS_17 ((mask) / 10) | | ------------------ | | | | 1760| 0|#define DIGITS_17(mask) PR (mask), n %= (mask), DIGITS_16 ((mask) / 10) | | | | ------------------ | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | | | #define DIGITS_17(mask) PR (mask), n %= (mask), DIGITS_16 ((mask) / 10) | | | | ------------------ | | | | | | 1759| 0|#define DIGITS_16(mask) PR (mask), n %= (mask), DIGITS_15 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | ------------------ | | | | | | #define DIGITS_16(mask) PR (mask), n %= (mask), DIGITS_15 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1758| 0|#define DIGITS_15(mask) PR (mask), n %= (mask), DIGITS_14 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | ------------------ | | | | | | | | #define DIGITS_15(mask) PR (mask), n %= (mask), DIGITS_14 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1757| 0|#define DIGITS_14(mask) PR (mask), n %= (mask), DIGITS_13 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | ------------------ | | | | | | | | | | #define DIGITS_14(mask) PR (mask), n %= (mask), DIGITS_13 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1756| 0|#define DIGITS_13(mask) PR (mask), n %= (mask), DIGITS_12 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define DIGITS_13(mask) PR (mask), n %= (mask), DIGITS_12 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1755| 0|#define DIGITS_12(mask) PR (mask), n %= (mask), DIGITS_11 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define DIGITS_12(mask) PR (mask), n %= (mask), DIGITS_11 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1754| 0|#define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | #define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1750| 0|#define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | #define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1749| 0|#define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | #define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1748| 0|#define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 1747| 0|#define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 1746| 0|#define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1745| 0|#define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1744| 0|#define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1743| 0|#define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1742| 0|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1741| 0|#define DIGITS_1(mask) PR (mask) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1836:12): [True: 0, False: 0] ------------------ 1837| 0| else DIGITS_19 (1000000000*(W)1000000000); ------------------ | | 1762| 0|#define DIGITS_19(mask) PR (mask), n %= (mask), DIGITS_18 ((mask) / 10) | | ------------------ | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | ------------------ | | #define DIGITS_19(mask) PR (mask), n %= (mask), DIGITS_18 ((mask) / 10) | | ------------------ | | | | 1761| 0|#define DIGITS_18(mask) PR (mask), n %= (mask), DIGITS_17 ((mask) / 10) | | | | ------------------ | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | ------------------ | | | | #define DIGITS_18(mask) PR (mask), n %= (mask), DIGITS_17 ((mask) / 10) | | | | ------------------ | | | | | | 1760| 0|#define DIGITS_17(mask) PR (mask), n %= (mask), DIGITS_16 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | ------------------ | | | | | | #define DIGITS_17(mask) PR (mask), n %= (mask), DIGITS_16 ((mask) / 10) | | | | | | ------------------ | | | | | | | | 1759| 0|#define DIGITS_16(mask) PR (mask), n %= (mask), DIGITS_15 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | ------------------ | | | | | | | | #define DIGITS_16(mask) PR (mask), n %= (mask), DIGITS_15 ((mask) / 10) | | | | | | | | ------------------ | | | | | | | | | | 1758| 0|#define DIGITS_15(mask) PR (mask), n %= (mask), DIGITS_14 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | ------------------ | | | | | | | | | | #define DIGITS_15(mask) PR (mask), n %= (mask), DIGITS_14 ((mask) / 10) | | | | | | | | | | ------------------ | | | | | | | | | | | | 1757| 0|#define DIGITS_14(mask) PR (mask), n %= (mask), DIGITS_13 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | ------------------ | | | | | | | | | | | | #define DIGITS_14(mask) PR (mask), n %= (mask), DIGITS_13 ((mask) / 10) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 1756| 0|#define DIGITS_13(mask) PR (mask), n %= (mask), DIGITS_12 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | #define DIGITS_13(mask) PR (mask), n %= (mask), DIGITS_12 ((mask) / 10) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 1755| 0|#define DIGITS_12(mask) PR (mask), n %= (mask), DIGITS_11 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | #define DIGITS_12(mask) PR (mask), n %= (mask), DIGITS_11 ((mask) / 10) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 1754| 0|#define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | #define DIGITS_11(mask) PR (mask), n %= (mask), DIGITS_10 ((mask) / 10) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 1750| 0|#define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | #define DIGITS_10(mask) PR (mask), n %= (mask), DIGITS_9 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 1749| 0|#define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_9(mask) PR (mask), n %= (mask), DIGITS_8 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 1748| 0|#define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_8(mask) PR (mask), n %= (mask), DIGITS_7 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 1747| 0|#define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_7(mask) PR (mask), n %= (mask), DIGITS_6 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1746| 0|#define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_6(mask) PR (mask), n %= (mask), DIGITS_5 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1745| 0|#define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_5(mask) PR (mask), n %= (mask), DIGITS_4 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1744| 0|#define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_4(mask) PR (mask), n %= (mask), DIGITS_3 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1743| 0|#define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_3(mask) PR (mask), n %= (mask), DIGITS_2 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1742| 0|#define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | #define DIGITS_2(mask) PR (mask), n %= (mask), DIGITS_1 ((mask) / 10) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1741| 0|#define DIGITS_1(mask) PR (mask) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 1734| 0|#define PR(mask) *p++ = n / (mask) + '0' | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1838| | 1839| 9.20k| if (last_digit_char) ------------------ | Branch (1839:7): [True: 0, False: 9.20k] ------------------ 1840| 0| *p++ = last_digit_char; 1841| | 1842| 9.20k| *p = '\0'; 1843| | 1844| 9.20k| return p; 1845| 9.20k|} number_to_static_string: 1905| 9.20k|{ 1906| 9.20k| static char ring[RING_SIZE][24]; 1907| 9.20k| static int ringpos; 1908| 9.20k| char *buf = ring[ringpos]; 1909| 9.20k| number_to_string (buf, number); 1910| 9.20k| ringpos = (ringpos + 1) % RING_SIZE; ------------------ | | 1870| 9.20k|#define RING_SIZE 3 ------------------ 1911| 9.20k| return buf; 1912| 9.20k|} convert_to_bits: 1918| 2.91k|{ 1919| 2.91k| if (opt.report_bps) ------------------ | Branch (1919:7): [True: 0, False: 2.91k] ------------------ 1920| 0| return num * 8; 1921| 2.91k| return num; 1922| 2.91k|} determine_screen_width: 1930| 1|{ 1931| | /* If there's a way to get the terminal size using POSIX 1932| | tcgetattr(), somebody please tell me. */ 1933| 1|#ifdef TIOCGWINSZ 1934| 1| int fd; 1935| 1| struct winsize wsz; 1936| | 1937| 1| if (opt.lfilename != NULL && opt.show_progress != 1) ------------------ | Branch (1937:7): [True: 0, False: 1] | Branch (1937:32): [True: 0, False: 0] ------------------ 1938| 0| return 0; 1939| | 1940| 1| fd = fileno (stderr); 1941| 1| if (ioctl (fd, TIOCGWINSZ, &wsz) < 0) ------------------ | Branch (1941:7): [True: 1, False: 0] ------------------ 1942| 1| return 0; /* most likely ENOTTY */ 1943| | 1944| 0| return wsz.ws_col; 1945| |#elif defined(WINDOWS) 1946| | CONSOLE_SCREEN_BUFFER_INFO csbi; 1947| | if (!GetConsoleScreenBufferInfo (GetStdHandle (STD_ERROR_HANDLE), &csbi)) 1948| | return 0; 1949| | return csbi.dwSize.X; 1950| |#else /* neither TIOCGWINSZ nor WINDOWS */ 1951| | return 0; 1952| |#endif /* neither TIOCGWINSZ nor WINDOWS */ 1953| 1|} print_decimal: 2628| 1.06k|{ 2629| 1.06k| static char buf[32]; 2630| 1.06k| double n = number >= 0 ? number : -number; ------------------ | Branch (2630:14): [True: 1.06k, False: 0] ------------------ 2631| | 2632| 1.06k| if (n >= 9.95) ------------------ | Branch (2632:7): [True: 0, False: 1.06k] ------------------ 2633| | /* Cut off at 9.95 because the below %.1f would round 9.96 to 2634| | "10.0" instead of "10". OTOH 9.94 will print as "9.9". */ 2635| 0| snprintf (buf, sizeof buf, "%.0f", number); 2636| 1.06k| else if (n >= 0.95) ------------------ | Branch (2636:12): [True: 45, False: 1.01k] ------------------ 2637| 45| snprintf (buf, sizeof buf, "%.1f", number); 2638| 1.01k| else if (n >= 0.001) ------------------ | Branch (2638:12): [True: 0, False: 1.01k] ------------------ 2639| 0| snprintf (buf, sizeof buf, "%.1g", number); 2640| 1.01k| else if (n >= 0.0005) ------------------ | Branch (2640:12): [True: 0, False: 1.01k] ------------------ 2641| | /* round [0.0005, 0.001) to 0.001 */ 2642| 0| snprintf (buf, sizeof buf, "%.3f", number); 2643| 1.01k| else 2644| | /* print numbers close to 0 as 0, not 0.000 */ 2645| 1.01k| strcpy (buf, "0"); 2646| | 2647| 1.06k| return buf; 2648| 1.06k|}