DOCSLIB.ORG

Beginning C for Java Programmers ---C Started

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Beginning C for Java Programmers ---C Started cnotes.txt Tue Mar 28 15:19:23 2017 1 cnotes.txt Tue Mar 28 15:19:23 2017 2 Beginning C for Java Programmers --------------------------------- C Syntax C started in the early 1970s as a systems-programming --------- language. Much C syntax was borrowed by Java. Higher level than assembly language. Same control structures as Java. Lower level than most other languages. C99 allows declaring variable in for loop K & R : Kernighan and Ritchie and anywhere in code. (Like Java) Influential 1978 book ANSI C requires that local vars be declared Greatly tamed in 1989: ANSI C "C89" or "C90" before any statements in any {.....} block. Also revised 1999 and 2011. Array syntax is not as "logical" as Java’s cnotes.txt Tue Mar 28 15:19:23 2017 3 cnotes.txt Tue Mar 28 15:19:23 2017 4 The Preprocessor Macros in the C Preprocessor ---------------- ----------------------------- Unlike Java, the C compiler has a "preprocessor" #define FOO 12*2 that does textual substitutions and "conditional compilation" before the "real compiler" thereafter, wherever the symbol FOO occurs in your runs. code, it is textually replaced by 12*2 . Think find-and-replace. This was borrowed from assembly languages. Macro can have parameters Fancy uses of preprocessor are often deprecated, especially since C99. #define BAR(x) 12*x Still commonly used use for defining constants If we have BAR(3*z) in your code, it is textually and in doing the C equivalent to Java’s "import". replaced by 12*3*z Preprocessor "directives" start with #. No ’;’ at end #undef BAR will "undefine" BAR. After this, BAR(3*z) remains as is. cnotes.txt Tue Mar 28 15:19:23 2017 5 cnotes.txt Tue Mar 28 15:19:23 2017 6 Perils of Macros Making Strings and Concatenating Tokens ----------------- --------------------------------------- #define SQUARE(x) ((x)*(x)) (optional fancy topic) used much later with In a macro definition, the # operator puts quote marks around a macro argument. int x = 0; int y = SQUARE(x++); #define STRINGIFYME(x) # x What value for x is expected by a programmer STRINGIFYME(owen) expands to "owen" looking only at these lines? The ## operator joins two tokens together. What value does x actually have? #define DECL_FUNC(name) int name ## _xy (int z){\ return(3 + name);} then DECL_FUNC(owen) ends up defining a function called owen_xy that returns 3 + owen cnotes.txt Tue Mar 28 15:19:23 2017 7 cnotes.txt Tue Mar 28 15:19:23 2017 8 Predefined Macros Conditional Compilation in C ------------------ ---------------------------- __FILE__ and __LINE__ expand to the current src #if ZZ == 1 #ifdef FOO code file name and line number. Good for ...somecode1... ..... auto-generated warning messages etc. #else #else ...somecode2... ..... __func__ name of current function (C99) #endif #endif also #ifndef Check a Boolean condition that can be evaluated at compile time, or chk definedness ** Determines whether somecode1 or somecode2 is seen by the real compiler Only one of the 2 sequences is used ** cnotes.txt Tue Mar 28 15:19:23 2017 9 cnotes.txt Tue Mar 28 15:19:23 2017 10 Conditional Compilation part II #include statement -------------------------------- ------------------ Conditional compilation is often used to tailor #include "foo.h" will cause the contents of your the code for a particular models of computer. file foo.h to be inserted in place of the #include statement. And to ensure that a given "include file" isn’t "copy paste the file here, please" seen too many times (more later) #include is usually used like "import" in Java. It makes available library things. Most C programs have a line #include <stdio.h> since you can’t print otherwise. (note angle brackets for system libraries) cnotes.txt Tue Mar 28 15:19:23 2017 11 cnotes.txt Tue Mar 28 15:19:23 2017 12 Simple C program Common C Programming Conventions ----------------- -------------------------------- #include <stdio.h> Whereas camelCase is the standard in Java, in C the #define N 5 tradition is to use underscores_to_separate the int g; various parts of a compound identifier. // C99-style comment: program needs a main() UPPER CASE is conventionally used for preprocessor int main(void) { macros used as constants and some macros with int i; arguments (but other macros-with-arguments get written in lower case, pretending to be functions) g = N; for (i=0; i < g; ++i) printf("Hello world"); } cnotes.txt Tue Mar 28 15:19:23 2017 13 cnotes.txt Tue Mar 28 15:19:23 2017 14 Enums C has no objects ------ ----------------- As in Java, C89 provides enumerated types Methods are called "functions". enum studentkind {Undergrad, Grad}; Equivalent to Java static methods. enum studentkind sk = Undergrad; A program consists of a bunch of functions, segmented into multiple source code files (sometimes called "modules"). Need main(). C allows you to group related data together (just like a class does). Called a "struct". More later. If you want C with objects, you want C++ (or Objective C) cnotes.txt Tue Mar 28 15:19:23 2017 15 cnotes.txt Tue Mar 28 15:19:23 2017 16 Order of declaration matters Example ---------------------------- -------- /* doubleslashed comments only with C99 */ A function cannot be called before (in source-code order) it has been declared. int foo(int a); /* function prototype */ It can be declared and defined by giving its code double bar(int x, int y) { /* defined */ (like giving code for a static method). return foo( 2*x*y); /* uses foo */ } Or it can just be declared by giving its parameters .... and return type. Called a "function prototype". int foo(int a) { int x; A full definition must then be given afterward if (a==0) return bar(a,a); else return 27; } cnotes.txt Tue Mar 28 15:19:23 2017 17 cnotes.txt Tue Mar 28 15:19:23 2017 18 Library header files Void parameter list -------------------- ------------------- A function with no parameters uses void in its One of the main things contained in library parameter list. header files (eg, <stdio.h>) are the function prototypes for the routines that int foobar(void) {.....} the library makes available. vs Java’s int foobar() {....} (Often also some constant declarations and data type (struct) definitions) So <stdio.h> contains prototypes for printf scanf various file I/O routines cnotes.txt Tue Mar 28 15:19:23 2017 19 cnotes.txt Tue Mar 28 15:19:23 2017 20 Order of Parameter Evaluation Static Functions and Extern Variables ----------------------------- ------------------------------------- For functions with multiple parameters, it is If you use the qualifier "static" when defining undefined in which order the parameters are a function, it will not be exported for linking, evaluated. which is the default. { int i=0; Keyword extern is used when a variable is being foo(i++,i++); imported from another module. One of the } modules needs you may have called foo(0,1) or foo(1,0). extern int v; int v; Do not rely on any particular behaviour. to define the value and pass to the linker. Or use extern int v=23; cnotes.txt Tue Mar 28 15:19:23 2017 21 cnotes.txt Tue Mar 28 15:19:23 2017 22 Stack Frames Widening and Narrowing Rules ------------ ---------------------------- Compilers generate stack frames according to the approved calling conventions for that system. Widening: conversion of a datatype to one that that can handle all the original values (and maybe more) Look at the Resources section: ARM Stack (eg, short to int) Frame Layout (Windows CE 5.0). Narrowing: conversion to a more restricted datatype. More later about "alloca()". Risk a value won’t be representable anymore. Appears consistent with AAPCS. In Java, you need explicit typecasts more often than you do in C. Note the "Frame Pointer". Some calling conventions use frame pointers (aka BP); others don’t. This one int i = 3.14; //narrowing, Java needs typecast requires FP in only some cases. float f = 3; // widening, Java is also ok with this my_arg_should_be_float(3.14); // narrowing, Java cast cnotes.txt Tue Mar 28 15:19:23 2017 23 cnotes.txt Tue Mar 28 15:19:23 2017 24 Promotion Simple IO in C ---------- ----------------- If i is an int and l is a long, i*l is same as (long)i * l (same as Java) printf for screen output (note: Java now has printf!) also putchar What if i is an int and u is an unsigned int. scanf and getchar for keyboard input What is i*u? printf takes first a "format string", then a Ans: same as (unsigned int)i * u variable # of things No such issue in Java, since no unsigned... eg printf("Hello world!"); How about if c is a signed character and u is printf("value of x=%d, and y=%s", an unsigned int? x, my_str); c*u is same as ( (unsigned int) ( (int) c))* u scanf uses a format string too ---> assuming 2’s complement, using sign extension scanf("%d %d %d", &x, &y, &z); Note use of "address-of" operator & Reason will be explained later. cnotes.txt Tue Mar 28 15:19:23 2017 25 cnotes.txt Tue Mar 28 15:19:23 2017 26 Getchar and the EOF bug I/O Buffering ----------------------- -------------- Function getchar() returns a character from the On many systems, input is buffered: nothing happens standard input stream (normally, the keyboard). until a newline is hit. (Until then you can edit your keyboard input). If there are no more characters (standard input has closed), it returns the value EOF. And many systems buffer output: nothing actually gets sent to the screen (or to a file) until a getchar() actually returns an int. EOF is usually newline is sent, or more than some number of kb -1.
Load more

Recommended publications
  • Exploring C Semantics and Pointer Provenance
    Exploring C Semantics and Pointer Provenance KAYVAN MEMARIAN, University of Cambridge VICTOR B. F. GOMES, University of Cambridge BROOKS DAVIS, SRI International STEPHEN KELL, University of Cambridge ALEXANDER RICHARDSON, University of Cambridge ROBERT N. M. WATSON, University of Cambridge PETER SEWELL, University of Cambridge The semantics of pointers and memory objects in C has been a vexed question for many years. C values cannot be treated as either purely abstract or purely concrete entities: the language exposes their representations, 67 but compiler optimisations rely on analyses that reason about provenance and initialisation status, not just runtime representations. The ISO WG14 standard leaves much of this unclear, and in some respects differs with de facto standard usage — which itself is difficult to investigate. In this paper we explore the possible source-language semantics for memory objects and pointers, in ISO C and in C as it is used and implemented in practice, focussing especially on pointer provenance. We aim to, as far as possible, reconcile the ISO C standard, mainstream compiler behaviour, and the semantics relied on by the corpus of existing C code. We present two coherent proposals, tracking provenance via integers and not; both address many design questions. We highlight some pros and cons and open questions, and illustrate the discussion with a library of test cases. We make our semantics executable as a test oracle, integrating it with the Cerberus semantics for much of the rest of C, which we have made substantially more complete and robust, and equipped with a web-interface GUI. This allows us to experimentally assess our proposals on those test cases.
    [Show full text]
  • Timur Doumler @Timur Audio
    Type punning in modern C++ version 1.1 Timur Doumler @timur_audio C++ Russia 30 October 2019 Image: ESA/Hubble Type punning in modern C++ 2 How not to do type punning in modern C++ 3 How to write portable code that achieves the same effect as type punning in modern C++ 4 How to write portable code that achieves the same effect as type punning in modern C++ without causing undefined behaviour 5 6 7 � 8 � (�) 9 10 11 12 struct Widget { virtual void doSomething() { printf("Widget"); } }; struct Gizmo { virtual void doSomethingCompletelyDifferent() { printf("Gizmo"); } }; int main() { Gizmo g; Widget* w = (Widget*)&g; w->doSomething(); } Example from Luna @lunasorcery 13 struct Widget { virtual void doSomething() { printf("Widget"); } }; struct Gizmo { virtual void doSomethingCompletelyDifferent() { printf("Gizmo"); } }; int main() { Gizmo g; Widget* w = (Widget*)&g; w->doSomething(); } Example from Luna @lunasorcery 14 15 Don’t use C-style casts. 16 struct Widget { virtual void doSomething() { printf("Widget"); } }; struct Gizmo { virtual void doSomethingCompletelyDifferent() { printf("Gizmo"); } }; int main() { Gizmo g; Widget* w = (Widget*)&g; w->doSomething(); } Example from Luna @lunasorcery 17 18 19 20 float F0 00 80 01 int F0 00 80 01 21 float F0 00 80 01 int F0 00 80 01 float F0 00 80 01 char* std::byte* F0 00 80 01 22 float F0 00 80 01 int F0 00 80 01 float F0 00 80 01 char* std::byte* F0 00 80 01 Widget F0 00 80 01 01 BD 83 E3 float[2] F0 00 80 01 01 BD 83 E3 23 float F0 00 80 01 int F0 00 80 01 float F0 00 80 01 char* std::byte*
    [Show full text]
  • Effective Types: Examples (P1796R0) 2 3 4 PETER SEWELL, University of Cambridge 5 KAYVAN MEMARIAN, University of Cambridge 6 VICTOR B
    1 Effective types: examples (P1796R0) 2 3 4 PETER SEWELL, University of Cambridge 5 KAYVAN MEMARIAN, University of Cambridge 6 VICTOR B. F. GOMES, University of Cambridge 7 JENS GUSTEDT, INRIA 8 HUBERT TONG 9 10 11 This is a collection of examples exploring the semantics that should be allowed for objects 12 and subobjects in allocated regions – especially, where the defined/undefined-behaviour 13 boundary should be, and how that relates to compiler alias analysis. The examples are in 14 C, but much should be similar in C++. We refer to the ISO C notion of effective types, 15 but that turns out to be quite flawed. Some examples at the end (from Hubert Tong) show 16 that existing compiler behaviour is not consistent with type-changing updates. 17 This is an updated version of part of n2294 C Memory Object Model Study Group: 18 Progress Report, 2018-09-16. 19 1 INTRODUCTION 20 21 Paragraphs 6.5p{6,7} of the standard introduce effective types. These were added to 22 C in C99 to permit compilers to do optimisations driven by type-based alias analysis, 23 by ruling out programs involving unannotated aliasing of references to different types 24 (regarding them as having undefined behaviour). However, this is one of the less clear, 25 less well-understood, and more controversial aspects of the standard, as one can see from 1 2 26 various GCC and Linux Kernel mailing list threads , blog postings , and the responses to 3 4 27 Questions 10, 11, and 15 of our survey . See also earlier committee discussion .
    [Show full text]
  • Aliasing Restrictions of C11 Formalized in Coq
    Aliasing restrictions of C11 formalized in Coq Robbert Krebbers Radboud University Nijmegen December 11, 2013 @ CPP, Melbourne, Australia int f(int *p, int *q) { int x = *p; *q = 314; return x; } If p and q alias, the original value n of *p is returned n p q Optimizing x away is unsound: 314 would be returned Alias analysis: to determine whether pointers can alias Aliasing Aliasing: multiple pointers referring to the same object Optimizing x away is unsound: 314 would be returned Alias analysis: to determine whether pointers can alias Aliasing Aliasing: multiple pointers referring to the same object int f(int *p, int *q) { int x = *p; *q = 314; return x; } If p and q alias, the original value n of *p is returned n p q Alias analysis: to determine whether pointers can alias Aliasing Aliasing: multiple pointers referring to the same object int f(int *p, int *q) { int x = *p; *q = 314; return x *p; } If p and q alias, the original value n of *p is returned n p q Optimizing x away is unsound: 314 would be returned Aliasing Aliasing: multiple pointers referring to the same object int f(int *p, int *q) { int x = *p; *q = 314; return x; } If p and q alias, the original value n of *p is returned n p q Optimizing x away is unsound: 314 would be returned Alias analysis: to determine whether pointers can alias It can still be called with aliased pointers: x union { int x; float y; } u; y u.x = 271; return h(&u.x, &u.y); &u.x &u.y C89 allows p and q to be aliased, and thus requires it to return 271 C99/C11 allows type-based alias analysis: I A compiler
    [Show full text]
  • SATE V Ockham Sound Analysis Criteria
    NISTIR 8113 SATE V Ockham Sound Analysis Criteria Paul E. Black Athos Ribeiro This publication is available free of charge from: https://doi.org/10.6028/NIST.IR.8113 NISTIR 8113 SATE V Ockham Sound Analysis Criteria Paul E. Black Software and Systems Division Information Technology Laboratory Athos Ribeiro Department of Computer Science University of Sao˜ Paulo Sao˜ Paulo, SP Brazil This publication is available free of charge from: https://doi.org/10.6028/NIST.IR.8113 March 2016 Including updates as of June 2017 U.S. Department of Commerce Wilbur L. Ross, Jr., Secretary National Institute of Standards and Technology Kent Rochford, Acting NIST Director and Under Secretary of Commerce for Standards and Technology Abstract Static analyzers examine the source or executable code of programs to find problems. Many static analyzers use heuristics or approximations to handle programs up to millions of lines of code. We established the Ockham Sound Analysis Criteria to recognize static analyzers whose findings are always correct. In brief the criteria are (1) the analyzer’s findings are claimed to always be correct, (2) it produces findings for most of a program, and (3) even one incorrect finding disqualifies an analyzer. This document begins by explaining the background and requirements of the Ockham Criteria. In Static Analysis Tool Exposition (SATE) V, only one tool was submitted to be re- viewed. Pascal Cuoq and Florent Kirchner ran the August 2013 development version of Frama-C on pertinent parts of the Juliet 1.2 test suite. We divided the warnings into eight classes, including improper buffer access, NULL pointer dereference, integer overflow, and use of uninitialized variable.
    [Show full text]
  • Half-Precision Floating-Point Formats for Pagerank: Opportunities and Challenges
    Half-Precision Floating-Point Formats for PageRank: Opportunities and Challenges Molahosseini, A. S., & Vandierendonck, H. (2020). Half-Precision Floating-Point Formats for PageRank: Opportunities and Challenges. In 2020 IEEE High Performance Extreme Computing Conference, HPEC 2020 [9286179] (IEEE High Performance Extreme Computing Conference: Proceedings). Institute of Electrical and Electronics Engineers Inc.. https://doi.org/10.1109/HPEC43674.2020.9286179 Published in: 2020 IEEE High Performance Extreme Computing Conference, HPEC 2020 Document Version: Peer reviewed version Queen's University Belfast - Research Portal: Link to publication record in Queen's University Belfast Research Portal Publisher rights Copyright 2020 IEEE. This work is made available online in accordance with the publisher’s policies. Please refer to any applicable terms of use of the publisher. General rights Copyright for the publications made accessible via the Queen's University Belfast Research Portal is retained by the author(s) and / or other copyright owners and it is a condition of accessing these publications that users recognise and abide by the legal requirements associated with these rights. Take down policy The Research Portal is Queen's institutional repository that provides access to Queen's research output. Every effort has been made to ensure that content in the Research Portal does not infringe any person's rights, or applicable UK laws. If you discover content in the Research Portal that you believe breaches copyright or violates any law, please
    [Show full text]
  • A Formal C Memory Model for Separation Logic
    Journal of Automated Reasoning manuscript No. (will be inserted by the editor) A Formal C Memory Model for Separation Logic Robbert Krebbers Received: n/a Abstract The core of a formal semantics of an imperative programming language is a memory model that describes the behavior of operations on the memory. Defining a memory model that matches the description of C in the C11 standard is challenging because C allows both high-level (by means of typed expressions) and low-level (by means of bit manipulation) memory accesses. The C11 standard has restricted the interaction between these two levels to make more effective compiler optimizations possible, at the expense of making the memory model complicated. We describe a formal memory model of the (non-concurrent part of the) C11 stan- dard that incorporates these restrictions, and at the same time describes low-level memory operations. This formal memory model includes a rich permission model to make it usable in separation logic and supports reasoning about program transfor- mations. The memory model and essential properties of it have been fully formalized using the Coq proof assistant. Keywords ISO C11 Standard · C Verification · Memory Models · Separation Logic · Interactive Theorem Proving · Coq 1 Introduction A memory model is the core of a semantics of an imperative programming language. It models the memory states and describes the behavior of memory operations. The main operations described by a C memory model are: – Reading a value at a given address. – Storing a value at a given address. – Allocating a new object to hold a local variable or storage obtained via malloc.
    [Show full text]
  • Low−Level C Topic for CS2263 Alumni −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− People Who Have Taken CS2617 Should Instead Read the Full Set of Notes (Cnotes)
    Low−level C Topic for CS2263 Alumni −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− People who have taken CS2617 should instead read the full set of notes (cnotes). Note: 2nd ed of textbook was for C−89 (classic "ANSI−C". Third is based on the 2018 revision. There were many changes in 30 years. C−11 and C−99 are also in widespread use. A new version (currently called C−2X) is expected in 2021 or 2022. Change look fairly small (new "decimal floats", if you care.) The Preprocessor −−−−−−−−−−−−−−−− Unlike Java, the C compiler has a "preprocessor" that does textual substitutions and "conditional compilation" before the "real compiler" runs. This was borrowed from assembly languages. Fancy uses of preprocessor are often deprecated, especially since C99. Still commonly used use for defining constants and in doing the C equivalent to Java’s "import". Preprocessor "directives" start with #. No ’;’ at end Macros in the C Preprocessor −−−−−−−−−−−−−−−−−−−−−−−−−−−−− #define FOO 12*2 thereafter, wherever the symbol FOO occurs in your code, it is textually replaced by 12*2 . Think find−and−replace. Macro can have parameters #define BAR(x) 12*x If we have BAR(3*z) in your code, it is textually replaced by 12*3*z #undef BAR will "undefine" BAR. After this, BAR(3*z) remains as is. Perils of Macros −−−−−−−−−−−−−−−−− #define SQUARE(x) ((x)*(x)) used much later with int x = 0; int y = SQUARE(x++); What value for x is expected by a programmer looking only at these lines? What value does x actually have? Making Strings and Concatenating Tokens −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− (optional fancy topic) In a macro definition, the # operator puts quote marks around a macro argument.
    [Show full text]
  • Exploring C Semantics and Pointer Provenance
    Exploring C Semantics and Pointer Provenance KAYVAN MEMARIAN, University of Cambridge, UK VICTOR B. F. GOMES, University of Cambridge, UK BROOKS DAVIS, SRI International, USA STEPHEN KELL, University of Cambridge, UK ALEXANDER RICHARDSON, University of Cambridge, UK ROBERT N. M. WATSON, University of Cambridge, UK PETER SEWELL, University of Cambridge, UK The semantics of pointers and memory objects in C has been a vexed question for many years. C values cannot be treated as either purely abstract or purely concrete entities: the language exposes their representations, 67 but compiler optimisations rely on analyses that reason about provenance and initialisation status, not just runtime representations. The ISO WG14 standard leaves much of this unclear, and in some respects differs with de facto standard usage — which itself is difficult to investigate. In this paper we explore the possible source-language semantics for memory objects and pointers, in ISO C and in C as it is used and implemented in practice, focussing especially on pointer provenance. We aim to, as far as possible, reconcile the ISO C standard, mainstream compiler behaviour, and the semantics relied on by the corpus of existing C code. We present two coherent proposals, tracking provenance via integers and not; both address many design questions. We highlight some pros and cons and open questions, and illustrate the discussion with a library of test cases. We make our semantics executable as a test oracle, integrating it with the Cerberus semantics for much of the rest of C, which we have made substantially more complete and robust, and equipped with a web-interface GUI.
    [Show full text]
  • Lenient Execution of C on a JVM How I Learned to Stop Worrying and Execute the Code
    Lenient Execution of C on a JVM How I Learned to Stop Worrying and Execute the Code Manuel Rigger Roland Schatz Johannes Kepler University Linz, Austria Oracle Labs, Austria [email protected] [email protected] Matthias Grimmer Hanspeter M¨ossenb¨ock Oracle Labs, Austria Johannes Kepler University Linz, Austria [email protected] [email protected] ABSTRACT that rely on undefined behavior risk introducing bugs that Most C programs do not strictly conform to the C standard, are hard to find, can result in security vulnerabilities, or and often show undefined behavior, e.g., on signed integer remain as time bombs in the code that explode after compiler overflow. When compiled by non-optimizing compilers, such updates [31, 44, 45]. programs often behave as the programmer intended. However, While bug-finding tools help programmers to find and optimizing compilers may exploit undefined semantics for eliminate undefined behavior in C programs, the majority more aggressive optimizations, thus possibly breaking the of C code will still contain at least some occurrences of non- code. Analysis tools can help to find and fix such issues. Alter- portable code. This includes unspecified and implementation- natively, one could define a C dialect in which clear semantics defined patterns, which do not render the whole program are defined for frequent program patterns whose behavior invalid, but can still cause surprising results. To address would otherwise be undefined. In this paper, we present such this, it has been advocated to come up with a more lenient a dialect, called Lenient C, that specifies semantics for behav- C dialect, that better suits the programmers' needs and ior that the standard left open for interpretation.
    [Show full text]
  • C Memory Object and Value Semantics: the Space of De Facto and ISO Standards
    DRAFT – WORK IN PROGRESS C memory object and value semantics: the space of de facto and ISO standards [This revises and extends WG14 N2013] Revision: 1571 2016-03-17 David Chisnall Justus Matthiesen Kayvan Memarian Peter Sewell Robert N. M. Watson University of Cambridge http://www.cl.cam.ac.uk/~pes20/cerberus/ Contents 2.3.1 Q8. Should intra-object pointer sub- traction give provenance-free inte- 1 Introduction5 ger results?............. 15 1.1 Experimental Testing............6 2.3.2 Q9. Can one make a usable off- 1.2 Summary of answers............7 set between two separately allocated objects by inter-object subtraction 2 Abstract Pointers7 (using either pointer or integer arith- 2.1 Pointer Provenance.............7 metic), to make a usable pointer to the second by adding the offset to 2.1.1 Q1. Must the pointer used for the first?............... 16 a memory access have the right provenance, i.e. be derived from 2.3.3 Q10. Presuming that one can the pointer to the original alloca- have valid pointers with multiple tion (with undefined behaviour oth- provenances, does an inter-object erwise)? (This lets compilers do pointer subtraction give a value with provenance-based alias analysis)..7 explicitly-unknown provenance or 2.1.2 Q2. Can equality testing on pointers something more specific?...... 18 be affected by pointer provenance 2.3.4 Q11. Is the XOR linked list idiom information?............9 supported?............. 18 2.1.3 GCC and ISO C11 differ on the re- 2.3.5 Q12. For arithmetic over prove- sult of a == comparison on a one- nanced integer values, is the prove- past pointer............
    [Show full text]
  • Overload Journal
    A ower Language Nee s Power Tools Smart editor Reliable with full language support refactorings Support for C++03/C++ll, Rename, Extract Function -:(r):- Boost andlibc++,C++ 7 Constant/ Variable, templates and macros. Change8ignature, & more Code generation Profound and navigation code analysis Generate menu, On-the-f y, analysis Find context usages, with Gluick-fixes& dozens 0 Go to Symbol, and more ofsmart checks GET A C++ DEVELOPMENT,:rOOL THAT YOU DESERV ReSharper C++ AppCode CLion Visual Studio Extension IDE for iOS Cross-platform IDE for C•• developers and OS X development for C and C•• developers Start a free 30-day trial jb.gg/cpp-accu Find out more at www.qbssoftware.com QBS SOFTWARE OVERLOAD CONTENTS OVERLOAD 160 December 2020 Overload is a publication of the ACCU ISSN 1354-3172 For details of the ACCU, our publications Editor and activities, visit the ACCU website: Frances Buontempo [email protected] www.accu.org Advisors Ben Curry [email protected] Mikael Kilpeläinen [email protected] 4 Questions on the Form of Software Steve Love Lucian Radu Teodorescu considers whether the [email protected] difficulties in writing software are rooted in the Chris Oldwood essence of development. [email protected] Roger Orr 8 Building g++ from the [email protected] Balog Pal GCC Modules Branch [email protected] Roger Orr demonstrates how to get a compiler that Tor Arve Stangeland supports modules up and running. [email protected] Anthony Williams 10 Consuming the uk-covid19 API [email protected] Donald Hernik demonstrates how to wrangle data Advertising enquiries out of the UK API.
    [Show full text]